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

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

// fidl_experiment = output_index_json

#pragma once

#include "lib/fidl/cpp/internal/header.h"

namespace test {
namespace unknowninteractions {


//
// Domain objects declarations
//


class UnknownInteractionsProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsProtocolStrictTwoWayTableResponse;


class UnknownInteractionsProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsProtocol_StrictTwoWayTableErr_Result;


class UnknownInteractionsProtocol_FlexibleTwoWay_Response;


class UnknownInteractionsProtocol_FlexibleTwoWay_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayFields_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayFields_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayTable_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayTable_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayErr_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayErr_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result;


class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response;


class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result;


class UnknownInteractionsProtocolStrictEventFieldsRequest;


class UnknownInteractionsProtocolStrictEventUnionRequest;


class UnknownInteractionsProtocolStrictEventTableRequest;


class UnknownInteractionsProtocolFlexibleEventFieldsRequest;


class UnknownInteractionsProtocolFlexibleEventUnionRequest;


class UnknownInteractionsProtocolFlexibleEventTableRequest;


#ifdef __Fuchsia__

class UnknownInteractionsProtocol;
using UnknownInteractionsProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsProtocol>;

#endif  // __Fuchsia__



class UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsAjarProtocolStrictTwoWayTableResponse;


class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result;


class UnknownInteractionsAjarProtocolStrictEventFieldsRequest;


class UnknownInteractionsAjarProtocolStrictEventUnionRequest;


class UnknownInteractionsAjarProtocolStrictEventTableRequest;


class UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest;


class UnknownInteractionsAjarProtocolFlexibleEventUnionRequest;


class UnknownInteractionsAjarProtocolFlexibleEventTableRequest;


#ifdef __Fuchsia__

class UnknownInteractionsAjarProtocol;
using UnknownInteractionsAjarProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsAjarProtocol>;

#endif  // __Fuchsia__



class UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsClosedProtocolStrictTwoWayTableResponse;


class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result;


class UnknownInteractionsClosedProtocolStrictEventFieldsRequest;


class UnknownInteractionsClosedProtocolStrictEventUnionRequest;


class UnknownInteractionsClosedProtocolStrictEventTableRequest;


#ifdef __Fuchsia__

class UnknownInteractionsClosedProtocol;
using UnknownInteractionsClosedProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsClosedProtocol>;

#endif  // __Fuchsia__



class UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsDriverProtocolStrictTwoWayTableResponse;


class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response;


class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result;


class UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result;


class UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse;


class UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse;


class UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response;


class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result;



class UnknownInteractionsProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsProtocolStrictTwoWayUnionResponse(UnknownInteractionsProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocolStrictTwoWayTableResponse();
  UnknownInteractionsProtocolStrictTwoWayTableResponse(UnknownInteractionsProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsProtocolStrictTwoWayTableResponse();
  UnknownInteractionsProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsProtocol_StrictTwoWayErr_Result(UnknownInteractionsProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>;



class UnknownInteractionsProtocol_FlexibleTwoWay_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsProtocol_FlexibleTwoWay_Response() = default;
  explicit UnknownInteractionsProtocol_FlexibleTwoWay_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsProtocol_FlexibleTwoWay_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsProtocol_FlexibleTwoWay_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWay_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWay_Result();

  UnknownInteractionsProtocol_FlexibleTwoWay_Result(UnknownInteractionsProtocol_FlexibleTwoWay_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWay_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWay_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWay_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWay_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWay_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWay_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWay_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response{});
  }
  operator fpromise::result<void, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWay_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Result>;



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

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

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

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

using UnknownInteractionsProtocol_FlexibleTwoWayFields_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayFields_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(UnknownInteractionsProtocol_FlexibleTwoWayFields_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayFields_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayFields_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayFields_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response{std::move(result.value)});
  }
  operator fpromise::result<int32_t, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayFields_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response();
  ~UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response();

  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&);
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& set_some_field(int32_t value);
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response{std::move(result.value)});
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>;



class UnknownInteractionsProtocol_FlexibleTwoWayTable_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocol_FlexibleTwoWayTable_Response();
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Response(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&& other);
  ~UnknownInteractionsProtocol_FlexibleTwoWayTable_Response();
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocol_FlexibleTwoWayTable_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayTable_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(UnknownInteractionsProtocol_FlexibleTwoWayTable_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTable_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayTable_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayTable_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response{std::move(result.value)});
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayTable_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>;



class UnknownInteractionsProtocol_FlexibleTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Response() = default;
  explicit UnknownInteractionsProtocol_FlexibleTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsProtocol_FlexibleTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsProtocol_FlexibleTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayErr_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayErr_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayErr_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithErr(int32_t&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response{});
  }
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithErr(int32_t&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response();
  ~UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response();

  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&);
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithErr(int32_t&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>;



class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response();
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&& other);
  ~UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response();
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>;



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

  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result();
  ~UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result();

  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result&&);
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result&&);

  
  static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithErr(int32_t&&);
  static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>;
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>;



class UnknownInteractionsProtocolStrictEventFieldsRequest final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventFieldsRequest>;



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

  UnknownInteractionsProtocolStrictEventUnionRequest();
  ~UnknownInteractionsProtocolStrictEventUnionRequest();

  UnknownInteractionsProtocolStrictEventUnionRequest(UnknownInteractionsProtocolStrictEventUnionRequest&&);
  UnknownInteractionsProtocolStrictEventUnionRequest& operator=(UnknownInteractionsProtocolStrictEventUnionRequest&&);

  
  static UnknownInteractionsProtocolStrictEventUnionRequest WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocolStrictEventUnionRequest& set_some_field(int32_t value);
  UnknownInteractionsProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventUnionRequest>;



class UnknownInteractionsProtocolStrictEventTableRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocolStrictEventTableRequest& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocolStrictEventTableRequest();
  UnknownInteractionsProtocolStrictEventTableRequest(UnknownInteractionsProtocolStrictEventTableRequest&& other);
  ~UnknownInteractionsProtocolStrictEventTableRequest();
  UnknownInteractionsProtocolStrictEventTableRequest& operator=(UnknownInteractionsProtocolStrictEventTableRequest&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictEventTableRequest* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocolStrictEventTableRequest* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventTableRequest>;



class UnknownInteractionsProtocolFlexibleEventFieldsRequest final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsProtocolFlexibleEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventFieldsRequest>;



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

  UnknownInteractionsProtocolFlexibleEventUnionRequest();
  ~UnknownInteractionsProtocolFlexibleEventUnionRequest();

  UnknownInteractionsProtocolFlexibleEventUnionRequest(UnknownInteractionsProtocolFlexibleEventUnionRequest&&);
  UnknownInteractionsProtocolFlexibleEventUnionRequest& operator=(UnknownInteractionsProtocolFlexibleEventUnionRequest&&);

  
  static UnknownInteractionsProtocolFlexibleEventUnionRequest WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsProtocolFlexibleEventUnionRequest& set_some_field(int32_t value);
  UnknownInteractionsProtocolFlexibleEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsProtocolFlexibleEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventUnionRequest>;



class UnknownInteractionsProtocolFlexibleEventTableRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsProtocolFlexibleEventTableRequest& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsProtocolFlexibleEventTableRequest();
  UnknownInteractionsProtocolFlexibleEventTableRequest(UnknownInteractionsProtocolFlexibleEventTableRequest&& other);
  ~UnknownInteractionsProtocolFlexibleEventTableRequest();
  UnknownInteractionsProtocolFlexibleEventTableRequest& operator=(UnknownInteractionsProtocolFlexibleEventTableRequest&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleEventTableRequest* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsProtocolFlexibleEventTableRequest* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsProtocolFlexibleEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventTableRequest>;


#ifdef __Fuchsia__

  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  



class UnknownInteractionsProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleOneWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFields(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnion(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTable(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnionErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTableErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
};
  
  
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayFieldsResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayUnionResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayTableResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayTableErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWay_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayFields_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayTable_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventFieldsRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventUnionRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventTableRequestTable;
  
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventFieldsRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventUnionRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventTableRequestTable;

}  // namespace _internal

class UnknownInteractionsProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__




class UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsAjarProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarProtocolStrictTwoWayTableResponse();
  UnknownInteractionsAjarProtocolStrictTwoWayTableResponse(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsAjarProtocolStrictTwoWayTableResponse();
  UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>;



class UnknownInteractionsAjarProtocolStrictEventFieldsRequest final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsAjarProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>;



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

  UnknownInteractionsAjarProtocolStrictEventUnionRequest();
  ~UnknownInteractionsAjarProtocolStrictEventUnionRequest();

  UnknownInteractionsAjarProtocolStrictEventUnionRequest(UnknownInteractionsAjarProtocolStrictEventUnionRequest&&);
  UnknownInteractionsAjarProtocolStrictEventUnionRequest& operator=(UnknownInteractionsAjarProtocolStrictEventUnionRequest&&);

  
  static UnknownInteractionsAjarProtocolStrictEventUnionRequest WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarProtocolStrictEventUnionRequest& set_some_field(int32_t value);
  UnknownInteractionsAjarProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventUnionRequest>;



class UnknownInteractionsAjarProtocolStrictEventTableRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarProtocolStrictEventTableRequest& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarProtocolStrictEventTableRequest();
  UnknownInteractionsAjarProtocolStrictEventTableRequest(UnknownInteractionsAjarProtocolStrictEventTableRequest&& other);
  ~UnknownInteractionsAjarProtocolStrictEventTableRequest();
  UnknownInteractionsAjarProtocolStrictEventTableRequest& operator=(UnknownInteractionsAjarProtocolStrictEventTableRequest&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictEventTableRequest* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarProtocolStrictEventTableRequest* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventTableRequest>;



class UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsAjarProtocolFlexibleEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>;



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

  UnknownInteractionsAjarProtocolFlexibleEventUnionRequest();
  ~UnknownInteractionsAjarProtocolFlexibleEventUnionRequest();

  UnknownInteractionsAjarProtocolFlexibleEventUnionRequest(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest&&);
  UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& operator=(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest&&);

  
  static UnknownInteractionsAjarProtocolFlexibleEventUnionRequest WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& set_some_field(int32_t value);
  UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarProtocolFlexibleEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>;



class UnknownInteractionsAjarProtocolFlexibleEventTableRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarProtocolFlexibleEventTableRequest& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarProtocolFlexibleEventTableRequest();
  UnknownInteractionsAjarProtocolFlexibleEventTableRequest(UnknownInteractionsAjarProtocolFlexibleEventTableRequest&& other);
  ~UnknownInteractionsAjarProtocolFlexibleEventTableRequest();
  UnknownInteractionsAjarProtocolFlexibleEventTableRequest& operator=(UnknownInteractionsAjarProtocolFlexibleEventTableRequest&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolFlexibleEventTableRequest* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarProtocolFlexibleEventTableRequest* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarProtocolFlexibleEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventTableRequest>;


#ifdef __Fuchsia__

  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  



class UnknownInteractionsAjarProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleOneWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
};
  
  
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayTableResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventFieldsRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventUnionRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventTableRequestTable;
  
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventFieldsRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventUnionRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventTableRequestTable;

}  // namespace _internal

class UnknownInteractionsAjarProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__




class UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsClosedProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsClosedProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsClosedProtocolStrictTwoWayTableResponse();
  UnknownInteractionsClosedProtocolStrictTwoWayTableResponse(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsClosedProtocolStrictTwoWayTableResponse();
  UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsClosedProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>;



class UnknownInteractionsClosedProtocolStrictEventFieldsRequest final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsClosedProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>;



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

  UnknownInteractionsClosedProtocolStrictEventUnionRequest();
  ~UnknownInteractionsClosedProtocolStrictEventUnionRequest();

  UnknownInteractionsClosedProtocolStrictEventUnionRequest(UnknownInteractionsClosedProtocolStrictEventUnionRequest&&);
  UnknownInteractionsClosedProtocolStrictEventUnionRequest& operator=(UnknownInteractionsClosedProtocolStrictEventUnionRequest&&);

  
  static UnknownInteractionsClosedProtocolStrictEventUnionRequest WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsClosedProtocolStrictEventUnionRequest& set_some_field(int32_t value);
  UnknownInteractionsClosedProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsClosedProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventUnionRequest>;



class UnknownInteractionsClosedProtocolStrictEventTableRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsClosedProtocolStrictEventTableRequest& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsClosedProtocolStrictEventTableRequest();
  UnknownInteractionsClosedProtocolStrictEventTableRequest(UnknownInteractionsClosedProtocolStrictEventTableRequest&& other);
  ~UnknownInteractionsClosedProtocolStrictEventTableRequest();
  UnknownInteractionsClosedProtocolStrictEventTableRequest& operator=(UnknownInteractionsClosedProtocolStrictEventTableRequest&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictEventTableRequest* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsClosedProtocolStrictEventTableRequest* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsClosedProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventTableRequest>;


#ifdef __Fuchsia__

  
  
  
  
  
  
  
  
  
  
  
  
  



class UnknownInteractionsClosedProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
};
  
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayTableResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventFieldsRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventUnionRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventTableRequestTable;

}  // namespace _internal

class UnknownInteractionsClosedProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t));
    

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

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

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__




class UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsDriverProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>;



class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response() = default;
  explicit UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWay_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response{});
  }
  operator fpromise::result<void, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWay_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>;



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

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

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

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response{std::move(result.value)});
  }
  operator fpromise::result<int32_t, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& set_some_field(int32_t value);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response{std::move(result.value)});
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>;



class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response();
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&& other);
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response();
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response{std::move(result.value)});
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response, ::fidl::FrameworkErr>() && {
    if (is_framework_err()) {
      return fpromise::error(framework_err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response response_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>;



class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response() = default;
  explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithErr(int32_t&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response{});
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithErr(int32_t&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithErr(int32_t&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>;



class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response();
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&& other);
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response();
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>;



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

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result();
  ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result();

  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result&&);
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result&&);

  
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithErr(int32_t&&);
  static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithFrameworkErr(::fidl::FrameworkErr&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    kFrameworkErr = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_err(int32_t value);

  bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr; }
  
  ::fidl::FrameworkErr& framework_err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr);
    return framework_err_;
  }
  
  const ::fidl::FrameworkErr& framework_err() const {
    ZX_ASSERT(is_framework_err());
    return framework_err_;
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_framework_err(::fidl::FrameworkErr value);

  ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>;
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && {
    if (is_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err()));
    }
    if (is_framework_err()) {
      return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err()));
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response response_;
    int32_t err_;
    ::fidl::FrameworkErr framework_err_;
  };
};

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

using UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>;



class UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>;



class UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse final {
 public:
  static const fidl_type_t* FidlType;
  
  int32_t some_field{};

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

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

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

using UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>;



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

  UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse();
  ~UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse();

  UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse&&);
  UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse&&);

  
  static UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value);
  UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>;



class UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse&& other);
  ~UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse();
  UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>;



class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response() = default;
  explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {}
  uint8_t ResultValue_() { return std::move(__reserved); }
  explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) {
  }
  operator ::std::tuple<>() && {
    return std::make_tuple(
    );
  }
  
  uint8_t __reserved= 0u;

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

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

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>;



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

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result();
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result();

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result&&);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result&&);

  
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response&&);
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>;
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response{});
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response{});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<void, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok();
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>;



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

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

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

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>;



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

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result();
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result();

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result&&);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result&&);

  
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response&&);
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>;
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int32_t, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int32_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>;



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

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response();
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response();

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&);

  
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kSomeField = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; }
  
  int32_t& some_field() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField);
    return some_field_;
  }
  
  const int32_t& some_field() const {
    ZX_ASSERT(is_some_field());
    return some_field_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid:
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_);
      default:
        return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown;
    }
    
  }

  // 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_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid);
  union {
    int32_t some_field_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>;



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

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result();
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result();

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result&&);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result&&);

  
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&);
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>;
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> 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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>;



class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const int32_t& some_field() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return some_field_value_.value;
  }
  bool has_some_field() const {
    return field_presence_.IsSet<0>();
  }
  
  int32_t* mutable_some_field() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&some_field_value_.value);
    }
    return &some_field_value_.value;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value);
  void clear_some_field() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&some_field_value_.value);
  }

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&& other);
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response();
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset);
  zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_some_field {
    ValueUnion_some_field() {}
    ~ValueUnion_some_field() {}

    int32_t value;
  };
  ValueUnion_some_field some_field_value_;
};

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>;



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

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result();
  ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result();

  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result&&);
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result&&);

  
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&&);
  static UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; }
  
  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& response() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response value);

  bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; }
  
  int32_t& err() {
    EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr);
    return err_;
  }
  
  const int32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value);

  ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const {
    
    return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>;
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>&& result) {
    set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)});
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) {
      set_err(std::move(result.error));
  }
  UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response> 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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid);
  union {
    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response response_;
    int32_t err_;
  };
};

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

using UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>;


}  // namespace unknowninteractions
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest);

    ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest);

    ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _value,
                         ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest);

    ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest);

    ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _value,
                         ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr:
        return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _value,
                         ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response, 1> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>::value
    && IsMemcpyCompatible<uint8_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {};




template<>
struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant<
    !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>::value
    && IsMemcpyCompatible<int32_t>::value> {};


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

template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField:
        return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, 16> {};

inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _value,
                         ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response> {
  bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const {
    if (_lhs.has_some_field()) {
      if (!_rhs.has_some_field()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) {
        return false;
      }
    } else if (_rhs.has_some_field()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>
    : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result);

    ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid):
        return true;
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};

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

#ifdef __Fuchsia__

using UnknownInteractionsProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsProtocol>;
class UnknownInteractionsProtocol_Proxy;
class UnknownInteractionsProtocol_Stub;
class UnknownInteractionsProtocol_EventSender;
class UnknownInteractionsProtocol_Sync;
using UnknownInteractionsProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsProtocol>;
class UnknownInteractionsProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kUnknownInteractionsProtocol_StrictOneWay_Ordinal = 0x4e7273b964d117a6lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleOneWay_Ordinal = 0x818bb3a7a910446lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWay_Ordinal = 0x734c996b0f37b942lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayFields_Ordinal = 0x334f4e7fff460ae3lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayUnion_Ordinal = 0x2212805eca592cadlu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayTable_Ordinal = 0x746ebf8659ff23b7lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayErr_Ordinal = 0x6d1c6002c51bb967lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayFieldsErr_Ordinal = 0x2182a49480e5bd2blu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayUnionErr_Ordinal = 0x453af745d38b20calu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayTableErr_Ordinal = 0x4c26c7ab89cb68d8lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWay_Ordinal = 0x4a5bb3397008b7clu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayFields_Ordinal = 0x3b13f82f44813a32lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayUnion_Ordinal = 0x44301e4e8d514fb6lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayTable_Ordinal = 0x7f492934b6c76187lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayErr_Ordinal = 0x61240f878cc37c07lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Ordinal = 0xf2b9611a9089b05lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Ordinal = 0x2172940a75f107d7lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayTableErr_Ordinal = 0x6d8aab48e1693bf2lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictEvent_Ordinal = 0x9842669255c4fc1lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictEventFields_Ordinal = 0x7b75ae46520ee732lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictEventUnion_Ordinal = 0x3663b5197598cbdalu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_StrictEventTable_Ordinal = 0x25a10039a9f96910lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEvent_Ordinal = 0x61bb1fab7d767866lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventFields_Ordinal = 0x3226dff9b0c1d801lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventUnion_Ordinal = 0x22afd161ca71e467lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventTable_Ordinal = 0x4f72dd46888b89e0lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;}  // namespace internal

#endif  // __Fuchsia__



#ifdef __Fuchsia__

using UnknownInteractionsAjarProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsAjarProtocol>;
class UnknownInteractionsAjarProtocol_Proxy;
class UnknownInteractionsAjarProtocol_Stub;
class UnknownInteractionsAjarProtocol_EventSender;
class UnknownInteractionsAjarProtocol_Sync;
using UnknownInteractionsAjarProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsAjarProtocol>;
class UnknownInteractionsAjarProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictOneWay_Ordinal = 0xd4663d6b2b5048blu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleOneWay_Ordinal = 0x2275b8171ae4834flu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWay_Ordinal = 0x50e66d328336038lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayFields_Ordinal = 0x1947e36d61e4493alu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayUnion_Ordinal = 0x5177371967e0e6d1lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayTable_Ordinal = 0x6f8f9343b34e2ed4lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayErr_Ordinal = 0x5b47637577c69006lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Ordinal = 0x844ff7bb3f186d9lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Ordinal = 0x2cbfd5a859d4ac95lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Ordinal = 0x30c9e1b3da57dc37lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEvent_Ordinal = 0x6022ae999e9dc2b0lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventFields_Ordinal = 0x510586752445c769lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventUnion_Ordinal = 0x57794b4cc91f816flu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventTable_Ordinal = 0x92639249201f89dlu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEvent_Ordinal = 0x11c9ba570ce71df3lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventFields_Ordinal = 0x3ba8fd32bf87d862lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventUnion_Ordinal = 0x7c3823f47ce0fcadlu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventTable_Ordinal = 0x9ca944d1d6436b0lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;}  // namespace internal

#endif  // __Fuchsia__



#ifdef __Fuchsia__

using UnknownInteractionsClosedProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsClosedProtocol>;
class UnknownInteractionsClosedProtocol_Proxy;
class UnknownInteractionsClosedProtocol_Stub;
class UnknownInteractionsClosedProtocol_EventSender;
class UnknownInteractionsClosedProtocol_Sync;
using UnknownInteractionsClosedProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsClosedProtocol>;
class UnknownInteractionsClosedProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictOneWay_Ordinal = 0x59282385962da24lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWay_Ordinal = 0x5eda305d6b22f1f7lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayFields_Ordinal = 0x1323afa3e0541253lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayUnion_Ordinal = 0x68b32554eb0f6fa7lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayTable_Ordinal = 0x6e4a94d44b69e785lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayErr_Ordinal = 0x4fa35d5433db4d3alu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Ordinal = 0xb22aebf23bb58fdlu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Ordinal = 0xcd65d4d29a43c80lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Ordinal = 0x117dde20b92f7b90lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEvent_Ordinal = 0xa8ee6ee302f693blu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventFields_Ordinal = 0x5d7c57b62e9c3a74lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventUnion_Ordinal = 0x3b8475deeb4a9d64lu;

constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventTable_Ordinal = 0x27da43fc85a7f5belu;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class UnknownInteractionsProtocol {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy;
  using Stub_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Stub;
  using EventSender_ = ::test::unknowninteractions::UnknownInteractionsProtocol_EventSender;
  using Sync_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Sync;
  virtual ~UnknownInteractionsProtocol();
      
  virtual void StrictOneWay() = 0;
      
  virtual void FlexibleOneWay() = 0;
  using StrictTwoWayCallback =
      fit::function<void()>;
      
  virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0;
  using StrictTwoWayFieldsCallback =
      fit::function<void(int32_t)>;
      
  virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0;
  using StrictTwoWayUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse)>;
      
  virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0;
  using StrictTwoWayTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse)>;
      
  virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0;
  using StrictTwoWayErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result)>;
      
  virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0;
  using StrictTwoWayFieldsErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result)>;
      
  virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0;
  using StrictTwoWayUnionErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result)>;
      
  virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0;
  using StrictTwoWayTableErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result)>;
      
  virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0;
  using FlexibleTwoWayCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result)>;
      
  virtual void FlexibleTwoWay(FlexibleTwoWayCallback callback) = 0;
  using FlexibleTwoWayFieldsCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result)>;
      
  virtual void FlexibleTwoWayFields(FlexibleTwoWayFieldsCallback callback) = 0;
  using FlexibleTwoWayUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result)>;
      
  virtual void FlexibleTwoWayUnion(FlexibleTwoWayUnionCallback callback) = 0;
  using FlexibleTwoWayTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result)>;
      
  virtual void FlexibleTwoWayTable(FlexibleTwoWayTableCallback callback) = 0;
  using FlexibleTwoWayErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result)>;
      
  virtual void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) = 0;
  using FlexibleTwoWayFieldsErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result)>;
      
  virtual void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCallback callback) = 0;
  using FlexibleTwoWayUnionErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result)>;
      
  virtual void FlexibleTwoWayUnionErr(FlexibleTwoWayUnionErrCallback callback) = 0;
  using FlexibleTwoWayTableErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result)>;
      
  virtual void FlexibleTwoWayTableErr(FlexibleTwoWayTableErrCallback callback) = 0;
  using StrictEventCallback =
      fit::function<void()>;
  using StrictEventFieldsCallback =
      fit::function<void(int32_t)>;
  using StrictEventUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest)>;
  using StrictEventTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest)>;
  using FlexibleEventCallback =
      fit::function<void()>;
  using FlexibleEventFieldsCallback =
      fit::function<void(int32_t)>;
  using FlexibleEventUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest)>;
  using FlexibleEventTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest)>;

  protected:
  // Allow the stub to access the handle_unknown_method method.
  friend class UnknownInteractionsProtocol_Stub;

  virtual void handle_unknown_method(uint64_t ordinal, bool method_has_response) = 0;
  
};

class UnknownInteractionsProtocol_RequestDecoder {
 public:
  UnknownInteractionsProtocol_RequestDecoder() = default;
  virtual ~UnknownInteractionsProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void StrictOneWay() = 0;
  virtual void FlexibleOneWay() = 0;
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields() = 0;
  virtual void StrictTwoWayUnion() = 0;
  virtual void StrictTwoWayTable() = 0;
  virtual void StrictTwoWayErr() = 0;
  virtual void StrictTwoWayFieldsErr() = 0;
  virtual void StrictTwoWayUnionErr() = 0;
  virtual void StrictTwoWayTableErr() = 0;
  virtual void FlexibleTwoWay() = 0;
  virtual void FlexibleTwoWayFields() = 0;
  virtual void FlexibleTwoWayUnion() = 0;
  virtual void FlexibleTwoWayTable() = 0;
  virtual void FlexibleTwoWayErr() = 0;
  virtual void FlexibleTwoWayFieldsErr() = 0;
  virtual void FlexibleTwoWayUnionErr() = 0;
  virtual void FlexibleTwoWayTableErr() = 0;
};

class UnknownInteractionsProtocol_ResponseDecoder {
 public:
  UnknownInteractionsProtocol_ResponseDecoder() = default;
  virtual ~UnknownInteractionsProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields(int32_t some_field) = 0;
  virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse UnknownInteractionsProtocolStrictTwoWayUnionResponse) = 0;
  virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse UnknownInteractionsProtocolStrictTwoWayTableResponse) = 0;
  virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result UnknownInteractionsProtocol_StrictTwoWayErr_Result) = 0;
  virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) = 0;
  virtual void FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result UnknownInteractionsProtocol_FlexibleTwoWay_Result) = 0;
  virtual void FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) = 0;
  virtual void FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) = 0;
  virtual void FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) = 0;
  virtual void FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) = 0;
  virtual void FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) = 0;
  virtual void FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) = 0;
  virtual void FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) = 0;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(int32_t some_field) = 0;
  virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) = 0;
  virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) = 0;
};

class UnknownInteractionsProtocol_EventSender {
 public:
  virtual ~UnknownInteractionsProtocol_EventSender();
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(int32_t some_field) = 0;
  virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) = 0;
  virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) = 0;
};

class UnknownInteractionsProtocol_Sync {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsProtocol_SyncProxy;
  virtual ~UnknownInteractionsProtocol_Sync();
  virtual zx_status_t StrictOneWay() = 0;
  virtual zx_status_t FlexibleOneWay() = 0;
  virtual zx_status_t StrictTwoWay() = 0;
  virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0;
  virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsProtocolStrictTwoWayUnionResponse) = 0;
  virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* out_UnknownInteractionsProtocolStrictTwoWayTableResponse) = 0;
  virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayErr_Result) = 0;
  virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) = 0;
  virtual zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_UnknownInteractionsProtocol_FlexibleTwoWay_Result) = 0;
  virtual zx_status_t FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) = 0;
  virtual zx_status_t FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) = 0;
  virtual zx_status_t FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) = 0;
  virtual zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) = 0;
  virtual zx_status_t FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) = 0;
  virtual zx_status_t FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) = 0;
  virtual zx_status_t FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictOneWay
  void StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleOneWay
  void FlexibleOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWay
  void StrictTwoWay(StrictTwoWayCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFields
  void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnion
  void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTable
  void StrictTwoWayTable(StrictTwoWayTableCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayErr
  void StrictTwoWayErr(StrictTwoWayErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFieldsErr
  void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnionErr
  void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTableErr
  void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay
  void FlexibleTwoWay(FlexibleTwoWayCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFields
  void FlexibleTwoWayFields(FlexibleTwoWayFieldsCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnion
  void FlexibleTwoWayUnion(FlexibleTwoWayUnionCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTable
  void FlexibleTwoWayTable(FlexibleTwoWayTableCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr
  void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFieldsErr
  void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnionErr
  void FlexibleTwoWayUnionErr(FlexibleTwoWayUnionErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTableErr
  void FlexibleTwoWayTableErr(FlexibleTwoWayTableErrCallback callback) override;
  StrictEventCallback StrictEvent;
  StrictEventFieldsCallback StrictEventFields;
  StrictEventUnionCallback StrictEventUnion;
  StrictEventTableCallback StrictEventTable;
  FlexibleEventCallback FlexibleEvent;
  FlexibleEventFieldsCallback FlexibleEventFields;
  FlexibleEventUnionCallback FlexibleEventUnion;
  FlexibleEventTableCallback FlexibleEventTable;

  fit::function<void(uint64_t)> handle_unknown_event;

 protected:
  void handle_unknown_method(uint64_t ordinal, bool method_has_response) override {
    // This method is only provided to satisfy the base interface. It's
    // protected and should never be called by generated code on the client
    // side, so it should never be called.
    ZX_PANIC("Unreachable: UnknownInteractionsProtocol_Proxy::handle_unknown_method should not be callable");
  }
  


 private:
  UnknownInteractionsProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy&) = delete;
  UnknownInteractionsProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy&) = delete;

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

class UnknownInteractionsProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsProtocol_EventSender {
 public:
  typedef class ::test::unknowninteractions::UnknownInteractionsProtocol UnknownInteractionsProtocol_clazz;
  explicit UnknownInteractionsProtocol_Stub(::test::unknowninteractions::UnknownInteractionsProtocol_Stub::UnknownInteractionsProtocol_clazz* impl);
  ~UnknownInteractionsProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void StrictEvent() override;
  void StrictEventFields(int32_t some_field) override;
  void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) override;
  void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) override;
  void FlexibleEvent() override;
  void FlexibleEventFields(int32_t some_field) override;
  void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) override;
  void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) override;

 private:
  ::test::unknowninteractions::UnknownInteractionsProtocol_Stub::UnknownInteractionsProtocol_clazz* impl_;
};

class UnknownInteractionsProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsProtocol_Sync {
 public:
  explicit UnknownInteractionsProtocol_SyncProxy(::zx::channel channel);
  ~UnknownInteractionsProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictOneWay
  zx_status_t StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleOneWay
  zx_status_t FlexibleOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWay
  zx_status_t StrictTwoWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFields
  zx_status_t StrictTwoWayFields(int32_t* out_some_field) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnion
  zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsProtocolStrictTwoWayUnionResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTable
  zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* out_UnknownInteractionsProtocolStrictTwoWayTableResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayErr
  zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFieldsErr
  zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnionErr
  zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTableErr
  zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay
  zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_UnknownInteractionsProtocol_FlexibleTwoWay_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFields
  zx_status_t FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnion
  zx_status_t FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTable
  zx_status_t FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr
  zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFieldsErr
  zx_status_t FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnionErr
  zx_status_t FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTableErr
  zx_status_t FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) override;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class UnknownInteractionsAjarProtocol {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy;
  using Stub_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub;
  using EventSender_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_EventSender;
  using Sync_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Sync;
  virtual ~UnknownInteractionsAjarProtocol();
      
  virtual void StrictOneWay() = 0;
      
  virtual void FlexibleOneWay() = 0;
  using StrictTwoWayCallback =
      fit::function<void()>;
      
  virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0;
  using StrictTwoWayFieldsCallback =
      fit::function<void(int32_t)>;
      
  virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0;
  using StrictTwoWayUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse)>;
      
  virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0;
  using StrictTwoWayTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse)>;
      
  virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0;
  using StrictTwoWayErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result)>;
      
  virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0;
  using StrictTwoWayFieldsErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result)>;
      
  virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0;
  using StrictTwoWayUnionErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result)>;
      
  virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0;
  using StrictTwoWayTableErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result)>;
      
  virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0;
  using StrictEventCallback =
      fit::function<void()>;
  using StrictEventFieldsCallback =
      fit::function<void(int32_t)>;
  using StrictEventUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest)>;
  using StrictEventTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest)>;
  using FlexibleEventCallback =
      fit::function<void()>;
  using FlexibleEventFieldsCallback =
      fit::function<void(int32_t)>;
  using FlexibleEventUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest)>;
  using FlexibleEventTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest)>;

  protected:
  // Allow the stub to access the handle_unknown_method method.
  friend class UnknownInteractionsAjarProtocol_Stub;

  virtual void handle_unknown_method(uint64_t ordinal) = 0;
};

class UnknownInteractionsAjarProtocol_RequestDecoder {
 public:
  UnknownInteractionsAjarProtocol_RequestDecoder() = default;
  virtual ~UnknownInteractionsAjarProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void StrictOneWay() = 0;
  virtual void FlexibleOneWay() = 0;
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields() = 0;
  virtual void StrictTwoWayUnion() = 0;
  virtual void StrictTwoWayTable() = 0;
  virtual void StrictTwoWayErr() = 0;
  virtual void StrictTwoWayFieldsErr() = 0;
  virtual void StrictTwoWayUnionErr() = 0;
  virtual void StrictTwoWayTableErr() = 0;
};

class UnknownInteractionsAjarProtocol_ResponseDecoder {
 public:
  UnknownInteractionsAjarProtocol_ResponseDecoder() = default;
  virtual ~UnknownInteractionsAjarProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields(int32_t some_field) = 0;
  virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) = 0;
  virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) = 0;
  virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) = 0;
  virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) = 0;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(int32_t some_field) = 0;
  virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) = 0;
  virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) = 0;
};

class UnknownInteractionsAjarProtocol_EventSender {
 public:
  virtual ~UnknownInteractionsAjarProtocol_EventSender();
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(int32_t some_field) = 0;
  virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) = 0;
  virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) = 0;
};

class UnknownInteractionsAjarProtocol_Sync {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_SyncProxy;
  virtual ~UnknownInteractionsAjarProtocol_Sync();
  virtual zx_status_t StrictOneWay() = 0;
  virtual zx_status_t FlexibleOneWay() = 0;
  virtual zx_status_t StrictTwoWay() = 0;
  virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0;
  virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) = 0;
  virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) = 0;
  virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) = 0;
  virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictOneWay
  void StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.FlexibleOneWay
  void FlexibleOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWay
  void StrictTwoWay(StrictTwoWayCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFields
  void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnion
  void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTable
  void StrictTwoWayTable(StrictTwoWayTableCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayErr
  void StrictTwoWayErr(StrictTwoWayErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFieldsErr
  void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnionErr
  void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTableErr
  void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override;
  StrictEventCallback StrictEvent;
  StrictEventFieldsCallback StrictEventFields;
  StrictEventUnionCallback StrictEventUnion;
  StrictEventTableCallback StrictEventTable;
  FlexibleEventCallback FlexibleEvent;
  FlexibleEventFieldsCallback FlexibleEventFields;
  FlexibleEventUnionCallback FlexibleEventUnion;
  FlexibleEventTableCallback FlexibleEventTable;

  fit::function<void(uint64_t)> handle_unknown_event;

 protected:
  void handle_unknown_method(uint64_t ordinal) override {
    // This method is only provided to satisfy the base interface. It's
    // protected and should never be called by generated code on the client
    // side, so it should never be called.
    ZX_PANIC("Unreachable: UnknownInteractionsAjarProtocol_Proxy::handle_unknown_method should not be callable");
  }


 private:
  UnknownInteractionsAjarProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy&) = delete;
  UnknownInteractionsAjarProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy&) = delete;

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

class UnknownInteractionsAjarProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsAjarProtocol_EventSender {
 public:
  typedef class ::test::unknowninteractions::UnknownInteractionsAjarProtocol UnknownInteractionsAjarProtocol_clazz;
  explicit UnknownInteractionsAjarProtocol_Stub(::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub::UnknownInteractionsAjarProtocol_clazz* impl);
  ~UnknownInteractionsAjarProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void StrictEvent() override;
  void StrictEventFields(int32_t some_field) override;
  void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) override;
  void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) override;
  void FlexibleEvent() override;
  void FlexibleEventFields(int32_t some_field) override;
  void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) override;
  void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) override;

 private:
  ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub::UnknownInteractionsAjarProtocol_clazz* impl_;
};

class UnknownInteractionsAjarProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Sync {
 public:
  explicit UnknownInteractionsAjarProtocol_SyncProxy(::zx::channel channel);
  ~UnknownInteractionsAjarProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictOneWay
  zx_status_t StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.FlexibleOneWay
  zx_status_t FlexibleOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWay
  zx_status_t StrictTwoWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFields
  zx_status_t StrictTwoWayFields(int32_t* out_some_field) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnion
  zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTable
  zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayErr
  zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFieldsErr
  zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnionErr
  zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTableErr
  zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) override;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class UnknownInteractionsClosedProtocol {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy;
  using Stub_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub;
  using EventSender_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_EventSender;
  using Sync_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Sync;
  virtual ~UnknownInteractionsClosedProtocol();
      
  virtual void StrictOneWay() = 0;
  using StrictTwoWayCallback =
      fit::function<void()>;
      
  virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0;
  using StrictTwoWayFieldsCallback =
      fit::function<void(int32_t)>;
      
  virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0;
  using StrictTwoWayUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse)>;
      
  virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0;
  using StrictTwoWayTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse)>;
      
  virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0;
  using StrictTwoWayErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result)>;
      
  virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0;
  using StrictTwoWayFieldsErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result)>;
      
  virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0;
  using StrictTwoWayUnionErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result)>;
      
  virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0;
  using StrictTwoWayTableErrCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result)>;
      
  virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0;
  using StrictEventCallback =
      fit::function<void()>;
  using StrictEventFieldsCallback =
      fit::function<void(int32_t)>;
  using StrictEventUnionCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest)>;
  using StrictEventTableCallback =
      fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest)>;

  
};

class UnknownInteractionsClosedProtocol_RequestDecoder {
 public:
  UnknownInteractionsClosedProtocol_RequestDecoder() = default;
  virtual ~UnknownInteractionsClosedProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void StrictOneWay() = 0;
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields() = 0;
  virtual void StrictTwoWayUnion() = 0;
  virtual void StrictTwoWayTable() = 0;
  virtual void StrictTwoWayErr() = 0;
  virtual void StrictTwoWayFieldsErr() = 0;
  virtual void StrictTwoWayUnionErr() = 0;
  virtual void StrictTwoWayTableErr() = 0;
};

class UnknownInteractionsClosedProtocol_ResponseDecoder {
 public:
  UnknownInteractionsClosedProtocol_ResponseDecoder() = default;
  virtual ~UnknownInteractionsClosedProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void StrictTwoWay() = 0;
  virtual void StrictTwoWayFields(int32_t some_field) = 0;
  virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) = 0;
  virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) = 0;
  virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) = 0;
  virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) = 0;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) = 0;
};

class UnknownInteractionsClosedProtocol_EventSender {
 public:
  virtual ~UnknownInteractionsClosedProtocol_EventSender();
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(int32_t some_field) = 0;
  virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) = 0;
  virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) = 0;
};

class UnknownInteractionsClosedProtocol_Sync {
 public:
  using Proxy_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_SyncProxy;
  virtual ~UnknownInteractionsClosedProtocol_Sync();
  virtual zx_status_t StrictOneWay() = 0;
  virtual zx_status_t StrictTwoWay() = 0;
  virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0;
  virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) = 0;
  virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) = 0;
  virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) = 0;
  virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) = 0;
  virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) = 0;
  virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictOneWay
  void StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWay
  void StrictTwoWay(StrictTwoWayCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFields
  void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnion
  void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTable
  void StrictTwoWayTable(StrictTwoWayTableCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayErr
  void StrictTwoWayErr(StrictTwoWayErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFieldsErr
  void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnionErr
  void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTableErr
  void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override;
  StrictEventCallback StrictEvent;
  StrictEventFieldsCallback StrictEventFields;
  StrictEventUnionCallback StrictEventUnion;
  StrictEventTableCallback StrictEventTable;

  


 private:
  UnknownInteractionsClosedProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy&) = delete;
  UnknownInteractionsClosedProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy&) = delete;

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

class UnknownInteractionsClosedProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsClosedProtocol_EventSender {
 public:
  typedef class ::test::unknowninteractions::UnknownInteractionsClosedProtocol UnknownInteractionsClosedProtocol_clazz;
  explicit UnknownInteractionsClosedProtocol_Stub(::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub::UnknownInteractionsClosedProtocol_clazz* impl);
  ~UnknownInteractionsClosedProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void StrictEvent() override;
  void StrictEventFields(int32_t some_field) override;
  void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) override;
  void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) override;

 private:
  ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub::UnknownInteractionsClosedProtocol_clazz* impl_;
};

class UnknownInteractionsClosedProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Sync {
 public:
  explicit UnknownInteractionsClosedProtocol_SyncProxy(::zx::channel channel);
  ~UnknownInteractionsClosedProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictOneWay
  zx_status_t StrictOneWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWay
  zx_status_t StrictTwoWay() override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFields
  zx_status_t StrictTwoWayFields(int32_t* out_some_field) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnion
  zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTable
  zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayErr
  zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFieldsErr
  zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnionErr
  zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) override;
  // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTableErr
  zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) override;

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

#endif  // __Fuchsia__

}  // namespace unknowninteractions
}  // namespace test