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

// fidl_experiment = output_index_json

#include <fidl/test.unknowninteractions/cpp/wire_types.h>

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

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayFieldsResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayFieldsResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayFieldsResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayUnionResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayTableResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayTableResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayTableResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventUnionRequest::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolStrictEventUnionRequest) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolStrictEventUnionRequest, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolStrictEventUnionRequest, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsProtocolFlexibleEventUnionRequest) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleEventUnionRequest, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsProtocolFlexibleEventUnionRequest, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolStrictEventUnionRequest) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictEventUnionRequest, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolStrictEventUnionRequest, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedProtocolStrictEventUnionRequest) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictEventUnionRequest, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedProtocolStrictEventUnionRequest, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

auto ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::Which() const -> ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::Ordinal::kSomeField:
      return static_cast<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::Tag>(ordinal_);
    default:
      return ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResult) == sizeof(fidl_union_t));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResult, envelope_) == offsetof(fidl_union_t, envelope));
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventTableRequest>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventTableRequest>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolStrictEventTableRequest::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventTableRequest>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventTableRequest>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsProtocolFlexibleEventTableRequest::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventTableRequest>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventTableRequest>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolStrictEventTableRequest::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventTableRequest>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventTableRequest>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarProtocolFlexibleEventTableRequest::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventTableRequest>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventTableRequest>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsClosedProtocolStrictEventTableRequest::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

bool ::fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  if (!some_field_.has_data()) {
    max_ordinal = 1;
  }
  return max_ordinal;
}

bool ::test_unknowninteractions::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse::HasUnknownData() const {
  if (max_ordinal_ > 1) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

#pragma clang diagnostic pop