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

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

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.padding/cpp/common_types.h>
#include <fidl/test.padding/cpp/markers.h>
#include <lib/fidl/cpp/natural_coding_traits.h>
#include <lib/fidl/cpp/natural_types.h>

#include <cinttypes>
#include <string>

#ifdef __Fuchsia__

#endif  // __Fuchsia__

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

namespace test_padding {

class Padding1ByteEnd;

class Padding2ByteEnd;

class Padding3ByteEnd;

class Padding4ByteEnd;

class Padding5ByteEnd;

class Padding6ByteEnd;

class Padding7ByteEnd;

class Padding1ByteMiddle;

class Padding2ByteMiddle;

class Padding3ByteMiddle;

class Padding4ByteMiddle;

class Padding5ByteMiddle;

class Padding6ByteMiddle;

class Padding7ByteMiddle;

class Padding4ByteAlignmentLength12;

class Padding2ByteAlignmentLength6;

class Padding1ByteEnd {
 private:
  struct Storage_;

 public:
  Padding1ByteEnd(Storage_ storage) noexcept;
  Padding1ByteEnd(uint16_t a, uint8_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding1ByteEnd| only if all of its members are default constructible.
  Padding1ByteEnd() = default;
#pragma clang diagnostic pop

  Padding1ByteEnd(Padding1ByteEnd&&) noexcept = default;
  Padding1ByteEnd& operator=(Padding1ByteEnd&&) noexcept = default;
  Padding1ByteEnd(const Padding1ByteEnd& other) noexcept;
  Padding1ByteEnd& operator=(const Padding1ByteEnd& other) noexcept;

  bool operator==(const Padding1ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteEnd, 4>::Equal(this, &other);
  }
  bool operator!=(const Padding1ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteEnd, 4>::Equal(this, &other);
  }

  uint16_t
  a() const {
    return storage_.a;
  }

  uint16_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding1ByteEnd& a(uint16_t value);

  uint8_t
  b() const {
    return storage_.b;
  }

  uint8_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding1ByteEnd& b(uint8_t value);

  Padding1ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint16_t a = {};
    uint8_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteEnd, 4>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding1ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 2});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint16_t>{
      .offset = 2,
      .mask = 0xff00,
  });
};

class Padding2ByteEnd {
 private:
  struct Storage_;

 public:
  Padding2ByteEnd(Storage_ storage) noexcept;
  Padding2ByteEnd(uint32_t a, uint16_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding2ByteEnd| only if all of its members are default constructible.
  Padding2ByteEnd() = default;
#pragma clang diagnostic pop

  Padding2ByteEnd(Padding2ByteEnd&&) noexcept = default;
  Padding2ByteEnd& operator=(Padding2ByteEnd&&) noexcept = default;
  Padding2ByteEnd(const Padding2ByteEnd& other) noexcept;
  Padding2ByteEnd& operator=(const Padding2ByteEnd& other) noexcept;

  bool operator==(const Padding2ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteEnd, 8>::Equal(this, &other);
  }
  bool operator!=(const Padding2ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteEnd, 8>::Equal(this, &other);
  }

  uint32_t
  a() const {
    return storage_.a;
  }

  uint32_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding2ByteEnd& a(uint32_t value);

  uint16_t
  b() const {
    return storage_.b;
  }

  uint16_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding2ByteEnd& b(uint16_t value);

  Padding2ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint32_t a = {};
    uint16_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteEnd, 8>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding2ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 4});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint32_t>{
      .offset = 4,
      .mask = 0xffff0000,
  });
};

class Padding3ByteEnd {
 private:
  struct Storage_;

 public:
  Padding3ByteEnd(Storage_ storage) noexcept;
  Padding3ByteEnd(uint32_t a, uint8_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding3ByteEnd| only if all of its members are default constructible.
  Padding3ByteEnd() = default;
#pragma clang diagnostic pop

  Padding3ByteEnd(Padding3ByteEnd&&) noexcept = default;
  Padding3ByteEnd& operator=(Padding3ByteEnd&&) noexcept = default;
  Padding3ByteEnd(const Padding3ByteEnd& other) noexcept;
  Padding3ByteEnd& operator=(const Padding3ByteEnd& other) noexcept;

  bool operator==(const Padding3ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteEnd, 8>::Equal(this, &other);
  }
  bool operator!=(const Padding3ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteEnd, 8>::Equal(this, &other);
  }

  uint32_t
  a() const {
    return storage_.a;
  }

  uint32_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding3ByteEnd& a(uint32_t value);

  uint8_t
  b() const {
    return storage_.b;
  }

  uint8_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding3ByteEnd& b(uint8_t value);

  Padding3ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint32_t a = {};
    uint8_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteEnd, 8>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding3ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 4});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint32_t>{
      .offset = 4,
      .mask = 0xffffff00,
  });
};

class Padding4ByteEnd {
 private:
  struct Storage_;

 public:
  Padding4ByteEnd(Storage_ storage) noexcept;
  Padding4ByteEnd(uint64_t a, uint32_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding4ByteEnd| only if all of its members are default constructible.
  Padding4ByteEnd() = default;
#pragma clang diagnostic pop

  Padding4ByteEnd(Padding4ByteEnd&&) noexcept = default;
  Padding4ByteEnd& operator=(Padding4ByteEnd&&) noexcept = default;
  Padding4ByteEnd(const Padding4ByteEnd& other) noexcept;
  Padding4ByteEnd& operator=(const Padding4ByteEnd& other) noexcept;

  bool operator==(const Padding4ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteEnd, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding4ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteEnd, 16>::Equal(this, &other);
  }

  uint64_t
  a() const {
    return storage_.a;
  }

  uint64_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding4ByteEnd& a(uint64_t value);

  uint32_t
  b() const {
    return storage_.b;
  }

  uint32_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding4ByteEnd& b(uint32_t value);

  Padding4ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint64_t a = {};
    uint32_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteEnd, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding4ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 8,
      .mask = 0xffffffff00000000,
  });
};

class Padding5ByteEnd {
 private:
  struct Storage_;

 public:
  Padding5ByteEnd(Storage_ storage) noexcept;
  Padding5ByteEnd(uint64_t a, uint16_t b, uint8_t c) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding5ByteEnd| only if all of its members are default constructible.
  Padding5ByteEnd() = default;
#pragma clang diagnostic pop

  Padding5ByteEnd(Padding5ByteEnd&&) noexcept = default;
  Padding5ByteEnd& operator=(Padding5ByteEnd&&) noexcept = default;
  Padding5ByteEnd(const Padding5ByteEnd& other) noexcept;
  Padding5ByteEnd& operator=(const Padding5ByteEnd& other) noexcept;

  bool operator==(const Padding5ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteEnd, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding5ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteEnd, 16>::Equal(this, &other);
  }

  uint64_t
  a() const {
    return storage_.a;
  }

  uint64_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding5ByteEnd& a(uint64_t value);

  uint16_t
  b() const {
    return storage_.b;
  }

  uint16_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding5ByteEnd& b(uint16_t value);

  uint8_t
  c() const {
    return storage_.c;
  }

  uint8_t& c() {
    return storage_.c;
  }

  // Setter for c.
  //

  Padding5ByteEnd& c(uint8_t value);

  Padding5ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint64_t a = {};
    uint16_t b = {};
    uint8_t c = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteEnd, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding5ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8}, ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::c, 10});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 8,
      .mask = 0xffffffffff000000,
  });
};

class Padding6ByteEnd {
 private:
  struct Storage_;

 public:
  Padding6ByteEnd(Storage_ storage) noexcept;
  Padding6ByteEnd(uint64_t a, uint16_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding6ByteEnd| only if all of its members are default constructible.
  Padding6ByteEnd() = default;
#pragma clang diagnostic pop

  Padding6ByteEnd(Padding6ByteEnd&&) noexcept = default;
  Padding6ByteEnd& operator=(Padding6ByteEnd&&) noexcept = default;
  Padding6ByteEnd(const Padding6ByteEnd& other) noexcept;
  Padding6ByteEnd& operator=(const Padding6ByteEnd& other) noexcept;

  bool operator==(const Padding6ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteEnd, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding6ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteEnd, 16>::Equal(this, &other);
  }

  uint64_t
  a() const {
    return storage_.a;
  }

  uint64_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding6ByteEnd& a(uint64_t value);

  uint16_t
  b() const {
    return storage_.b;
  }

  uint16_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding6ByteEnd& b(uint16_t value);

  Padding6ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint64_t a = {};
    uint16_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteEnd, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding6ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 8,
      .mask = 0xffffffffffff0000,
  });
};

class Padding7ByteEnd {
 private:
  struct Storage_;

 public:
  Padding7ByteEnd(Storage_ storage) noexcept;
  Padding7ByteEnd(uint64_t a, uint8_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding7ByteEnd| only if all of its members are default constructible.
  Padding7ByteEnd() = default;
#pragma clang diagnostic pop

  Padding7ByteEnd(Padding7ByteEnd&&) noexcept = default;
  Padding7ByteEnd& operator=(Padding7ByteEnd&&) noexcept = default;
  Padding7ByteEnd(const Padding7ByteEnd& other) noexcept;
  Padding7ByteEnd& operator=(const Padding7ByteEnd& other) noexcept;

  bool operator==(const Padding7ByteEnd& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteEnd, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding7ByteEnd& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteEnd, 16>::Equal(this, &other);
  }

  uint64_t
  a() const {
    return storage_.a;
  }

  uint64_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding7ByteEnd& a(uint64_t value);

  uint8_t
  b() const {
    return storage_.b;
  }

  uint8_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding7ByteEnd& b(uint8_t value);

  Padding7ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint64_t a = {};
    uint8_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteEnd, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding7ByteEnd>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 8,
      .mask = 0xffffffffffffff00,
  });
};

class Padding1ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding1ByteMiddle(Storage_ storage) noexcept;
  Padding1ByteMiddle(uint8_t a, uint16_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding1ByteMiddle| only if all of its members are default constructible.
  Padding1ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding1ByteMiddle(Padding1ByteMiddle&&) noexcept = default;
  Padding1ByteMiddle& operator=(Padding1ByteMiddle&&) noexcept = default;
  Padding1ByteMiddle(const Padding1ByteMiddle& other) noexcept;
  Padding1ByteMiddle& operator=(const Padding1ByteMiddle& other) noexcept;

  bool operator==(const Padding1ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteMiddle, 4>::Equal(this, &other);
  }
  bool operator!=(const Padding1ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteMiddle, 4>::Equal(this, &other);
  }

  uint8_t
  a() const {
    return storage_.a;
  }

  uint8_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding1ByteMiddle& a(uint8_t value);

  uint16_t
  b() const {
    return storage_.b;
  }

  uint16_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding1ByteMiddle& b(uint16_t value);

  Padding1ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint8_t a = {};
    uint16_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteMiddle, 4>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding1ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 2});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint16_t>{
      .offset = 0,
      .mask = 0xff00,
  });
};

class Padding2ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding2ByteMiddle(Storage_ storage) noexcept;
  Padding2ByteMiddle(uint16_t a, uint32_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding2ByteMiddle| only if all of its members are default constructible.
  Padding2ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding2ByteMiddle(Padding2ByteMiddle&&) noexcept = default;
  Padding2ByteMiddle& operator=(Padding2ByteMiddle&&) noexcept = default;
  Padding2ByteMiddle(const Padding2ByteMiddle& other) noexcept;
  Padding2ByteMiddle& operator=(const Padding2ByteMiddle& other) noexcept;

  bool operator==(const Padding2ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteMiddle, 8>::Equal(this, &other);
  }
  bool operator!=(const Padding2ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteMiddle, 8>::Equal(this, &other);
  }

  uint16_t
  a() const {
    return storage_.a;
  }

  uint16_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding2ByteMiddle& a(uint16_t value);

  uint32_t
  b() const {
    return storage_.b;
  }

  uint32_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding2ByteMiddle& b(uint32_t value);

  Padding2ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint16_t a = {};
    uint32_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteMiddle, 8>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding2ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 4});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint32_t>{
      .offset = 0,
      .mask = 0xffff0000,
  });
};

class Padding3ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding3ByteMiddle(Storage_ storage) noexcept;
  Padding3ByteMiddle(uint8_t a, uint32_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding3ByteMiddle| only if all of its members are default constructible.
  Padding3ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding3ByteMiddle(Padding3ByteMiddle&&) noexcept = default;
  Padding3ByteMiddle& operator=(Padding3ByteMiddle&&) noexcept = default;
  Padding3ByteMiddle(const Padding3ByteMiddle& other) noexcept;
  Padding3ByteMiddle& operator=(const Padding3ByteMiddle& other) noexcept;

  bool operator==(const Padding3ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteMiddle, 8>::Equal(this, &other);
  }
  bool operator!=(const Padding3ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteMiddle, 8>::Equal(this, &other);
  }

  uint8_t
  a() const {
    return storage_.a;
  }

  uint8_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding3ByteMiddle& a(uint8_t value);

  uint32_t
  b() const {
    return storage_.b;
  }

  uint32_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding3ByteMiddle& b(uint32_t value);

  Padding3ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint8_t a = {};
    uint32_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteMiddle, 8>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding3ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 4});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint32_t>{
      .offset = 0,
      .mask = 0xffffff00,
  });
};

class Padding4ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding4ByteMiddle(Storage_ storage) noexcept;
  Padding4ByteMiddle(uint32_t a, uint64_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding4ByteMiddle| only if all of its members are default constructible.
  Padding4ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding4ByteMiddle(Padding4ByteMiddle&&) noexcept = default;
  Padding4ByteMiddle& operator=(Padding4ByteMiddle&&) noexcept = default;
  Padding4ByteMiddle(const Padding4ByteMiddle& other) noexcept;
  Padding4ByteMiddle& operator=(const Padding4ByteMiddle& other) noexcept;

  bool operator==(const Padding4ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteMiddle, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding4ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteMiddle, 16>::Equal(this, &other);
  }

  uint32_t
  a() const {
    return storage_.a;
  }

  uint32_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding4ByteMiddle& a(uint32_t value);

  uint64_t
  b() const {
    return storage_.b;
  }

  uint64_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding4ByteMiddle& b(uint64_t value);

  Padding4ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint32_t a = {};
    uint64_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteMiddle, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding4ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 0,
      .mask = 0xffffffff00000000,
  });
};

class Padding5ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding5ByteMiddle(Storage_ storage) noexcept;
  Padding5ByteMiddle(uint16_t a, uint8_t b, uint64_t c) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding5ByteMiddle| only if all of its members are default constructible.
  Padding5ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding5ByteMiddle(Padding5ByteMiddle&&) noexcept = default;
  Padding5ByteMiddle& operator=(Padding5ByteMiddle&&) noexcept = default;
  Padding5ByteMiddle(const Padding5ByteMiddle& other) noexcept;
  Padding5ByteMiddle& operator=(const Padding5ByteMiddle& other) noexcept;

  bool operator==(const Padding5ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteMiddle, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding5ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteMiddle, 16>::Equal(this, &other);
  }

  uint16_t
  a() const {
    return storage_.a;
  }

  uint16_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding5ByteMiddle& a(uint16_t value);

  uint8_t
  b() const {
    return storage_.b;
  }

  uint8_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding5ByteMiddle& b(uint8_t value);

  uint64_t
  c() const {
    return storage_.c;
  }

  uint64_t& c() {
    return storage_.c;
  }

  // Setter for c.
  //

  Padding5ByteMiddle& c(uint64_t value);

  Padding5ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint16_t a = {};
    uint8_t b = {};
    uint64_t c = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteMiddle, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding5ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 2}, ::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::c, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 0,
      .mask = 0xffffffffff000000,
  });
};

class Padding6ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding6ByteMiddle(Storage_ storage) noexcept;
  Padding6ByteMiddle(uint16_t a, uint64_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding6ByteMiddle| only if all of its members are default constructible.
  Padding6ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding6ByteMiddle(Padding6ByteMiddle&&) noexcept = default;
  Padding6ByteMiddle& operator=(Padding6ByteMiddle&&) noexcept = default;
  Padding6ByteMiddle(const Padding6ByteMiddle& other) noexcept;
  Padding6ByteMiddle& operator=(const Padding6ByteMiddle& other) noexcept;

  bool operator==(const Padding6ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteMiddle, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding6ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteMiddle, 16>::Equal(this, &other);
  }

  uint16_t
  a() const {
    return storage_.a;
  }

  uint16_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding6ByteMiddle& a(uint16_t value);

  uint64_t
  b() const {
    return storage_.b;
  }

  uint64_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding6ByteMiddle& b(uint64_t value);

  Padding6ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint16_t a = {};
    uint64_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteMiddle, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding6ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 0,
      .mask = 0xffffffffffff0000,
  });
};

class Padding7ByteMiddle {
 private:
  struct Storage_;

 public:
  Padding7ByteMiddle(Storage_ storage) noexcept;
  Padding7ByteMiddle(uint8_t a, uint64_t b) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding7ByteMiddle| only if all of its members are default constructible.
  Padding7ByteMiddle() = default;
#pragma clang diagnostic pop

  Padding7ByteMiddle(Padding7ByteMiddle&&) noexcept = default;
  Padding7ByteMiddle& operator=(Padding7ByteMiddle&&) noexcept = default;
  Padding7ByteMiddle(const Padding7ByteMiddle& other) noexcept;
  Padding7ByteMiddle& operator=(const Padding7ByteMiddle& other) noexcept;

  bool operator==(const Padding7ByteMiddle& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteMiddle, 16>::Equal(this, &other);
  }
  bool operator!=(const Padding7ByteMiddle& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteMiddle, 16>::Equal(this, &other);
  }

  uint8_t
  a() const {
    return storage_.a;
  }

  uint8_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding7ByteMiddle& a(uint8_t value);

  uint64_t
  b() const {
    return storage_.b;
  }

  uint64_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding7ByteMiddle& b(uint64_t value);

  Padding7ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint8_t a = {};
    uint64_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteMiddle, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding7ByteMiddle>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
      .offset = 0,
      .mask = 0xffffffffffffff00,
  });
};

class Padding4ByteAlignmentLength12 {
 private:
  struct Storage_;

 public:
  Padding4ByteAlignmentLength12(Storage_ storage) noexcept;
  Padding4ByteAlignmentLength12(uint32_t a, uint8_t b, uint16_t c, uint16_t d) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding4ByteAlignmentLength12| only if all of its members are default constructible.
  Padding4ByteAlignmentLength12() = default;
#pragma clang diagnostic pop

  Padding4ByteAlignmentLength12(Padding4ByteAlignmentLength12&&) noexcept = default;
  Padding4ByteAlignmentLength12& operator=(Padding4ByteAlignmentLength12&&) noexcept = default;
  Padding4ByteAlignmentLength12(const Padding4ByteAlignmentLength12& other) noexcept;
  Padding4ByteAlignmentLength12& operator=(const Padding4ByteAlignmentLength12& other) noexcept;

  bool operator==(const Padding4ByteAlignmentLength12& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteAlignmentLength12, 12>::Equal(this, &other);
  }
  bool operator!=(const Padding4ByteAlignmentLength12& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteAlignmentLength12, 12>::Equal(this, &other);
  }

  uint32_t
  a() const {
    return storage_.a;
  }

  uint32_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding4ByteAlignmentLength12& a(uint32_t value);

  uint8_t
  b() const {
    return storage_.b;
  }

  uint8_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding4ByteAlignmentLength12& b(uint8_t value);

  uint16_t
  c() const {
    return storage_.c;
  }

  uint16_t& c() {
    return storage_.c;
  }

  // Setter for c.
  //

  Padding4ByteAlignmentLength12& c(uint16_t value);

  uint16_t
  d() const {
    return storage_.d;
  }

  uint16_t& d() {
    return storage_.d;
  }

  // Setter for d.
  //

  Padding4ByteAlignmentLength12& d(uint16_t value);

  Padding4ByteAlignmentLength12(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint32_t a = {};
    uint8_t b = {};
    uint16_t c = {};
    uint16_t d = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteAlignmentLength12, 12>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding4ByteAlignmentLength12>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 4}, ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::c, 6}, ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::d, 8});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint32_t>{
                                                       .offset = 4,
                                                       .mask = 0xff00,
                                                   },
                                                   ::fidl::internal::NaturalStructPadding<uint32_t>{
                                                       .offset = 8,
                                                       .mask = 0xffff0000,
                                                   });
};

class Padding2ByteAlignmentLength6 {
 private:
  struct Storage_;

 public:
  Padding2ByteAlignmentLength6(Storage_ storage) noexcept;
  Padding2ByteAlignmentLength6(uint8_t a, uint16_t b, uint8_t c) noexcept;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |Padding2ByteAlignmentLength6| only if all of its members are default constructible.
  Padding2ByteAlignmentLength6() = default;
#pragma clang diagnostic pop

  Padding2ByteAlignmentLength6(Padding2ByteAlignmentLength6&&) noexcept = default;
  Padding2ByteAlignmentLength6& operator=(Padding2ByteAlignmentLength6&&) noexcept = default;
  Padding2ByteAlignmentLength6(const Padding2ByteAlignmentLength6& other) noexcept;
  Padding2ByteAlignmentLength6& operator=(const Padding2ByteAlignmentLength6& other) noexcept;

  bool operator==(const Padding2ByteAlignmentLength6& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteAlignmentLength6, 6>::Equal(this, &other);
  }
  bool operator!=(const Padding2ByteAlignmentLength6& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteAlignmentLength6, 6>::Equal(this, &other);
  }

  uint8_t
  a() const {
    return storage_.a;
  }

  uint8_t& a() {
    return storage_.a;
  }

  // Setter for a.
  //

  Padding2ByteAlignmentLength6& a(uint8_t value);

  uint16_t
  b() const {
    return storage_.b;
  }

  uint16_t& b() {
    return storage_.b;
  }

  // Setter for b.
  //

  Padding2ByteAlignmentLength6& b(uint16_t value);

  uint8_t
  c() const {
    return storage_.c;
  }

  uint8_t& c() {
    return storage_.c;
  }

  // Setter for c.
  //

  Padding2ByteAlignmentLength6& c(uint8_t value);

  Padding2ByteAlignmentLength6(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
    uint8_t a = {};
    uint16_t b = {};
    uint8_t c = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteAlignmentLength6, 6>;
  friend struct ::fidl::internal::MemberVisitor<::test_padding::Padding2ByteAlignmentLength6>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 2}, ::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::c, 4});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint16_t>{
                                                       .offset = 0,
                                                       .mask = 0xff00,
                                                   },
                                                   ::fidl::internal::NaturalStructPadding<uint16_t>{
                                                       .offset = 4,
                                                       .mask = 0xff00,
                                                   });
};

inline Padding1ByteEnd::Padding1ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding1ByteEnd::Padding1ByteEnd(uint16_t a, uint8_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding1ByteEnd::Padding1ByteEnd(const ::test_padding::Padding1ByteEnd& other) noexcept : ::test_padding::Padding1ByteEnd(other.CloneStorage_()) {}
inline Padding1ByteEnd& ::test_padding::Padding1ByteEnd::operator=(const ::test_padding::Padding1ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding1ByteEnd::Padding1ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding1ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding1ByteEnd& Padding1ByteEnd::a(uint16_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding1ByteEnd& Padding1ByteEnd::b(uint8_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding2ByteEnd::Padding2ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding2ByteEnd::Padding2ByteEnd(uint32_t a, uint16_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding2ByteEnd::Padding2ByteEnd(const ::test_padding::Padding2ByteEnd& other) noexcept : ::test_padding::Padding2ByteEnd(other.CloneStorage_()) {}
inline Padding2ByteEnd& ::test_padding::Padding2ByteEnd::operator=(const ::test_padding::Padding2ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding2ByteEnd::Padding2ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding2ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding2ByteEnd& Padding2ByteEnd::a(uint32_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding2ByteEnd& Padding2ByteEnd::b(uint16_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding3ByteEnd::Padding3ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding3ByteEnd::Padding3ByteEnd(uint32_t a, uint8_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding3ByteEnd::Padding3ByteEnd(const ::test_padding::Padding3ByteEnd& other) noexcept : ::test_padding::Padding3ByteEnd(other.CloneStorage_()) {}
inline Padding3ByteEnd& ::test_padding::Padding3ByteEnd::operator=(const ::test_padding::Padding3ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding3ByteEnd::Padding3ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding3ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding3ByteEnd& Padding3ByteEnd::a(uint32_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding3ByteEnd& Padding3ByteEnd::b(uint8_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding4ByteEnd::Padding4ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding4ByteEnd::Padding4ByteEnd(uint64_t a, uint32_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding4ByteEnd::Padding4ByteEnd(const ::test_padding::Padding4ByteEnd& other) noexcept : ::test_padding::Padding4ByteEnd(other.CloneStorage_()) {}
inline Padding4ByteEnd& ::test_padding::Padding4ByteEnd::operator=(const ::test_padding::Padding4ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding4ByteEnd::Padding4ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding4ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding4ByteEnd& Padding4ByteEnd::a(uint64_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding4ByteEnd& Padding4ByteEnd::b(uint32_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding5ByteEnd::Padding5ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding5ByteEnd::Padding5ByteEnd(uint64_t a, uint16_t b, uint8_t c) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b),
                .c = std::move(c)}) {}
inline Padding5ByteEnd::Padding5ByteEnd(const ::test_padding::Padding5ByteEnd& other) noexcept : ::test_padding::Padding5ByteEnd(other.CloneStorage_()) {}
inline Padding5ByteEnd& ::test_padding::Padding5ByteEnd::operator=(const ::test_padding::Padding5ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding5ByteEnd::Padding5ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding5ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                          .c = {},
                                                                                                      }) {}
inline Padding5ByteEnd& Padding5ByteEnd::a(uint64_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding5ByteEnd& Padding5ByteEnd::b(uint16_t value) {
  storage_.b = std::move(value);
  return *this;
}
inline Padding5ByteEnd& Padding5ByteEnd::c(uint8_t value) {
  storage_.c = std::move(value);
  return *this;
}

inline Padding6ByteEnd::Padding6ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding6ByteEnd::Padding6ByteEnd(uint64_t a, uint16_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding6ByteEnd::Padding6ByteEnd(const ::test_padding::Padding6ByteEnd& other) noexcept : ::test_padding::Padding6ByteEnd(other.CloneStorage_()) {}
inline Padding6ByteEnd& ::test_padding::Padding6ByteEnd::operator=(const ::test_padding::Padding6ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding6ByteEnd::Padding6ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding6ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding6ByteEnd& Padding6ByteEnd::a(uint64_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding6ByteEnd& Padding6ByteEnd::b(uint16_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding7ByteEnd::Padding7ByteEnd(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding7ByteEnd::Padding7ByteEnd(uint64_t a, uint8_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding7ByteEnd::Padding7ByteEnd(const ::test_padding::Padding7ByteEnd& other) noexcept : ::test_padding::Padding7ByteEnd(other.CloneStorage_()) {}
inline Padding7ByteEnd& ::test_padding::Padding7ByteEnd::operator=(const ::test_padding::Padding7ByteEnd & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding7ByteEnd::Padding7ByteEnd(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding7ByteEnd(Storage_{
                                                                                                          .a = {},
                                                                                                          .b = {},
                                                                                                      }) {}
inline Padding7ByteEnd& Padding7ByteEnd::a(uint64_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding7ByteEnd& Padding7ByteEnd::b(uint8_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding1ByteMiddle::Padding1ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding1ByteMiddle::Padding1ByteMiddle(uint8_t a, uint16_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding1ByteMiddle::Padding1ByteMiddle(const ::test_padding::Padding1ByteMiddle& other) noexcept : ::test_padding::Padding1ByteMiddle(other.CloneStorage_()) {}
inline Padding1ByteMiddle& ::test_padding::Padding1ByteMiddle::operator=(const ::test_padding::Padding1ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding1ByteMiddle::Padding1ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding1ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding1ByteMiddle& Padding1ByteMiddle::a(uint8_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding1ByteMiddle& Padding1ByteMiddle::b(uint16_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding2ByteMiddle::Padding2ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding2ByteMiddle::Padding2ByteMiddle(uint16_t a, uint32_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding2ByteMiddle::Padding2ByteMiddle(const ::test_padding::Padding2ByteMiddle& other) noexcept : ::test_padding::Padding2ByteMiddle(other.CloneStorage_()) {}
inline Padding2ByteMiddle& ::test_padding::Padding2ByteMiddle::operator=(const ::test_padding::Padding2ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding2ByteMiddle::Padding2ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding2ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding2ByteMiddle& Padding2ByteMiddle::a(uint16_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding2ByteMiddle& Padding2ByteMiddle::b(uint32_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding3ByteMiddle::Padding3ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding3ByteMiddle::Padding3ByteMiddle(uint8_t a, uint32_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding3ByteMiddle::Padding3ByteMiddle(const ::test_padding::Padding3ByteMiddle& other) noexcept : ::test_padding::Padding3ByteMiddle(other.CloneStorage_()) {}
inline Padding3ByteMiddle& ::test_padding::Padding3ByteMiddle::operator=(const ::test_padding::Padding3ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding3ByteMiddle::Padding3ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding3ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding3ByteMiddle& Padding3ByteMiddle::a(uint8_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding3ByteMiddle& Padding3ByteMiddle::b(uint32_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding4ByteMiddle::Padding4ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding4ByteMiddle::Padding4ByteMiddle(uint32_t a, uint64_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding4ByteMiddle::Padding4ByteMiddle(const ::test_padding::Padding4ByteMiddle& other) noexcept : ::test_padding::Padding4ByteMiddle(other.CloneStorage_()) {}
inline Padding4ByteMiddle& ::test_padding::Padding4ByteMiddle::operator=(const ::test_padding::Padding4ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding4ByteMiddle::Padding4ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding4ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding4ByteMiddle& Padding4ByteMiddle::a(uint32_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding4ByteMiddle& Padding4ByteMiddle::b(uint64_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding5ByteMiddle::Padding5ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding5ByteMiddle::Padding5ByteMiddle(uint16_t a, uint8_t b, uint64_t c) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b),
                .c = std::move(c)}) {}
inline Padding5ByteMiddle::Padding5ByteMiddle(const ::test_padding::Padding5ByteMiddle& other) noexcept : ::test_padding::Padding5ByteMiddle(other.CloneStorage_()) {}
inline Padding5ByteMiddle& ::test_padding::Padding5ByteMiddle::operator=(const ::test_padding::Padding5ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding5ByteMiddle::Padding5ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding5ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                                .c = {},
                                                                                                            }) {}
inline Padding5ByteMiddle& Padding5ByteMiddle::a(uint16_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding5ByteMiddle& Padding5ByteMiddle::b(uint8_t value) {
  storage_.b = std::move(value);
  return *this;
}
inline Padding5ByteMiddle& Padding5ByteMiddle::c(uint64_t value) {
  storage_.c = std::move(value);
  return *this;
}

inline Padding6ByteMiddle::Padding6ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding6ByteMiddle::Padding6ByteMiddle(uint16_t a, uint64_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding6ByteMiddle::Padding6ByteMiddle(const ::test_padding::Padding6ByteMiddle& other) noexcept : ::test_padding::Padding6ByteMiddle(other.CloneStorage_()) {}
inline Padding6ByteMiddle& ::test_padding::Padding6ByteMiddle::operator=(const ::test_padding::Padding6ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding6ByteMiddle::Padding6ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding6ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding6ByteMiddle& Padding6ByteMiddle::a(uint16_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding6ByteMiddle& Padding6ByteMiddle::b(uint64_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding7ByteMiddle::Padding7ByteMiddle(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding7ByteMiddle::Padding7ByteMiddle(uint8_t a, uint64_t b) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b)}) {}
inline Padding7ByteMiddle::Padding7ByteMiddle(const ::test_padding::Padding7ByteMiddle& other) noexcept : ::test_padding::Padding7ByteMiddle(other.CloneStorage_()) {}
inline Padding7ByteMiddle& ::test_padding::Padding7ByteMiddle::operator=(const ::test_padding::Padding7ByteMiddle & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding7ByteMiddle::Padding7ByteMiddle(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding7ByteMiddle(Storage_{
                                                                                                                .a = {},
                                                                                                                .b = {},
                                                                                                            }) {}
inline Padding7ByteMiddle& Padding7ByteMiddle::a(uint8_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding7ByteMiddle& Padding7ByteMiddle::b(uint64_t value) {
  storage_.b = std::move(value);
  return *this;
}

inline Padding4ByteAlignmentLength12::Padding4ByteAlignmentLength12(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding4ByteAlignmentLength12::Padding4ByteAlignmentLength12(uint32_t a, uint8_t b, uint16_t c, uint16_t d) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b),
                .c = std::move(c),
                .d = std::move(d)}) {}
inline Padding4ByteAlignmentLength12::Padding4ByteAlignmentLength12(const ::test_padding::Padding4ByteAlignmentLength12& other) noexcept : ::test_padding::Padding4ByteAlignmentLength12(other.CloneStorage_()) {}
inline Padding4ByteAlignmentLength12& ::test_padding::Padding4ByteAlignmentLength12::operator=(const ::test_padding::Padding4ByteAlignmentLength12 & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding4ByteAlignmentLength12::Padding4ByteAlignmentLength12(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding4ByteAlignmentLength12(Storage_{
                                                                                                                                      .a = {},
                                                                                                                                      .b = {},
                                                                                                                                      .c = {},
                                                                                                                                      .d = {},
                                                                                                                                  }) {}
inline Padding4ByteAlignmentLength12& Padding4ByteAlignmentLength12::a(uint32_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding4ByteAlignmentLength12& Padding4ByteAlignmentLength12::b(uint8_t value) {
  storage_.b = std::move(value);
  return *this;
}
inline Padding4ByteAlignmentLength12& Padding4ByteAlignmentLength12::c(uint16_t value) {
  storage_.c = std::move(value);
  return *this;
}
inline Padding4ByteAlignmentLength12& Padding4ByteAlignmentLength12::d(uint16_t value) {
  storage_.d = std::move(value);
  return *this;
}

inline Padding2ByteAlignmentLength6::Padding2ByteAlignmentLength6(Storage_ storage) noexcept : storage_(std::move(storage)) {}
inline Padding2ByteAlignmentLength6::Padding2ByteAlignmentLength6(uint8_t a, uint16_t b, uint8_t c) noexcept
    : storage_({.a = std::move(a),
                .b = std::move(b),
                .c = std::move(c)}) {}
inline Padding2ByteAlignmentLength6::Padding2ByteAlignmentLength6(const ::test_padding::Padding2ByteAlignmentLength6& other) noexcept : ::test_padding::Padding2ByteAlignmentLength6(other.CloneStorage_()) {}
inline Padding2ByteAlignmentLength6& ::test_padding::Padding2ByteAlignmentLength6::operator=(const ::test_padding::Padding2ByteAlignmentLength6 & other) noexcept {
  storage_ = other.CloneStorage_();
  return *this;
}

inline Padding2ByteAlignmentLength6::Padding2ByteAlignmentLength6(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Padding2ByteAlignmentLength6(Storage_{
                                                                                                                                    .a = {},
                                                                                                                                    .b = {},
                                                                                                                                    .c = {},
                                                                                                                                }) {}
inline Padding2ByteAlignmentLength6& Padding2ByteAlignmentLength6::a(uint8_t value) {
  storage_.a = std::move(value);
  return *this;
}
inline Padding2ByteAlignmentLength6& Padding2ByteAlignmentLength6::b(uint16_t value) {
  storage_.b = std::move(value);
  return *this;
}
inline Padding2ByteAlignmentLength6& Padding2ByteAlignmentLength6::c(uint8_t value) {
  storage_.c = std::move(value);
  return *this;
}

}  // namespace test_padding
namespace fidl {

template <>
struct IsFidlType<::test_padding::Padding1ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding1ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 4;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding1ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding1ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteEnd, 4> {};

template <>
struct IsFidlType<::test_padding::Padding2ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding2ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 8;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding2ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding2ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteEnd, 8> {};

template <>
struct IsFidlType<::test_padding::Padding3ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding3ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 8;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding3ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding3ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteEnd, 8> {};

template <>
struct IsFidlType<::test_padding::Padding4ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding4ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding4ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding4ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteEnd, 16> {};

template <>
struct IsFidlType<::test_padding::Padding5ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding5ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding5ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding5ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteEnd, 16> {};

template <>
struct IsFidlType<::test_padding::Padding6ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding6ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding6ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding6ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteEnd, 16> {};

template <>
struct IsFidlType<::test_padding::Padding7ByteEnd> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding7ByteEnd> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding7ByteEnd> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding7ByteEnd, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteEnd, 16> {};

template <>
struct IsFidlType<::test_padding::Padding1ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding1ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 4;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding1ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding1ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding1ByteMiddle, 4> {};

template <>
struct IsFidlType<::test_padding::Padding2ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding2ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 8;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding2ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding2ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteMiddle, 8> {};

template <>
struct IsFidlType<::test_padding::Padding3ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding3ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 8;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding3ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding3ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding3ByteMiddle, 8> {};

template <>
struct IsFidlType<::test_padding::Padding4ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding4ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding4ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding4ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteMiddle, 16> {};

template <>
struct IsFidlType<::test_padding::Padding5ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding5ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding5ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding5ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding5ByteMiddle, 16> {};

template <>
struct IsFidlType<::test_padding::Padding6ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding6ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding6ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding6ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding6ByteMiddle, 16> {};

template <>
struct IsFidlType<::test_padding::Padding7ByteMiddle> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding7ByteMiddle> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding7ByteMiddle> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding7ByteMiddle, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding7ByteMiddle, 16> {};

template <>
struct IsFidlType<::test_padding::Padding4ByteAlignmentLength12> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding4ByteAlignmentLength12> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 12;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding4ByteAlignmentLength12> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding4ByteAlignmentLength12, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding4ByteAlignmentLength12, 12> {};

template <>
struct IsFidlType<::test_padding::Padding2ByteAlignmentLength6> : public std::true_type {};

template <>
struct TypeTraits<::test_padding::Padding2ByteAlignmentLength6> {
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kMaxDepth = 0;
  static constexpr uint32_t kPrimarySize = 6;
  static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr bool kHasPointer = false;
};

template <>
struct IsStruct<::test_padding::Padding2ByteAlignmentLength6> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_padding::Padding2ByteAlignmentLength6, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_padding::Padding2ByteAlignmentLength6, 6> {};

#pragma clang diagnostic pop

}  // namespace fidl