GeneratedJsonHandlers.cpp

// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionCesiumRTCJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionCesiumRTC.h>
#include <CesiumGltfReader/ExtensionCesiumRTCReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionCesiumRTCJsonHandler::ExtensionCesiumRTCJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _center() {}

void ExtensionCesiumRTCJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionCesiumRTC* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionCesiumRTCJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionCesiumRTC(
      CesiumGltf::ExtensionCesiumRTC::TypeName,
      str,
      *this->_pObject);
}

void ExtensionCesiumRTCJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions.emplace(extensionName, CesiumGltf::ExtensionCesiumRTC())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionCesiumRTC&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionCesiumRTCJsonHandler::readObjectKeyExtensionCesiumRTC(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionCesiumRTC& o) {
  using namespace std::string_literals;

  if ("center"s == str) {
    return property("center", this->_center, o.center);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionCesiumRTCReader::ExtensionCesiumRTCReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& ExtensionCesiumRTCReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionCesiumRTCReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumRTC>
ExtensionCesiumRTCReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionCesiumRTCJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumRTC>
ExtensionCesiumRTCReader::readFromJson(const rapidjson::Value& value) const {
  ExtensionCesiumRTCJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::ExtensionCesiumRTC>>
ExtensionCesiumRTCReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionCesiumRTC,
      ExtensionCesiumRTCJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionCesiumTileEdgesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionCesiumTileEdges.h>
#include <CesiumGltfReader/ExtensionCesiumTileEdgesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionCesiumTileEdgesJsonHandler::ExtensionCesiumTileEdgesJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _left(),
      _bottom(),
      _right(),
      _top() {}

void ExtensionCesiumTileEdgesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionCesiumTileEdges* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionCesiumTileEdgesJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionCesiumTileEdges(
      CesiumGltf::ExtensionCesiumTileEdges::TypeName,
      str,
      *this->_pObject);
}

void ExtensionCesiumTileEdgesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionCesiumTileEdges())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionCesiumTileEdges&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionCesiumTileEdgesJsonHandler::readObjectKeyExtensionCesiumTileEdges(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionCesiumTileEdges& o) {
  using namespace std::string_literals;

  if ("left"s == str) {
    return property("left", this->_left, o.left);
  }
  if ("bottom"s == str) {
    return property("bottom", this->_bottom, o.bottom);
  }
  if ("right"s == str) {
    return property("right", this->_right, o.right);
  }
  if ("top"s == str) {
    return property("top", this->_top, o.top);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionCesiumTileEdgesReader::ExtensionCesiumTileEdgesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionCesiumTileEdgesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionCesiumTileEdgesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumTileEdges>
ExtensionCesiumTileEdgesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionCesiumTileEdgesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumTileEdges>
ExtensionCesiumTileEdgesReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionCesiumTileEdgesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionCesiumTileEdges>>
ExtensionCesiumTileEdgesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionCesiumTileEdges,
      ExtensionCesiumTileEdgesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtInstanceFeaturesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtInstanceFeatures.h>
#include <CesiumGltfReader/ExtensionExtInstanceFeaturesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtInstanceFeaturesJsonHandler::
    ExtensionExtInstanceFeaturesJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _featureIds(options) {}

void ExtensionExtInstanceFeaturesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtInstanceFeatures* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtInstanceFeaturesJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtInstanceFeatures(
      CesiumGltf::ExtensionExtInstanceFeatures::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtInstanceFeaturesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionExtInstanceFeatures())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtInstanceFeatures&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtInstanceFeaturesJsonHandler::
    readObjectKeyExtensionExtInstanceFeatures(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtInstanceFeatures& o) {
  using namespace std::string_literals;

  if ("featureIds"s == str) {
    return property("featureIds", this->_featureIds, o.featureIds);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtInstanceFeaturesReader::ExtensionExtInstanceFeaturesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtInstanceFeaturesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtInstanceFeaturesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtInstanceFeatures>
ExtensionExtInstanceFeaturesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtInstanceFeaturesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtInstanceFeatures>
ExtensionExtInstanceFeaturesReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtInstanceFeaturesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtInstanceFeatures>>
ExtensionExtInstanceFeaturesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtInstanceFeatures,
      ExtensionExtInstanceFeaturesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtMeshFeaturesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtMeshFeatures.h>
#include <CesiumGltfReader/ExtensionExtMeshFeaturesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtMeshFeaturesJsonHandler::ExtensionExtMeshFeaturesJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _featureIds(options) {}

void ExtensionExtMeshFeaturesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtMeshFeatures* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtMeshFeaturesJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtMeshFeatures(
      CesiumGltf::ExtensionExtMeshFeatures::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtMeshFeaturesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionExtMeshFeatures())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtMeshFeatures&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionExtMeshFeaturesJsonHandler::readObjectKeyExtensionExtMeshFeatures(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionExtMeshFeatures& o) {
  using namespace std::string_literals;

  if ("featureIds"s == str) {
    return property("featureIds", this->_featureIds, o.featureIds);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtMeshFeaturesReader::ExtensionExtMeshFeaturesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtMeshFeaturesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtMeshFeaturesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtMeshFeatures>
ExtensionExtMeshFeaturesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtMeshFeaturesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtMeshFeatures>
ExtensionExtMeshFeaturesReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtMeshFeaturesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtMeshFeatures>>
ExtensionExtMeshFeaturesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtMeshFeatures,
      ExtensionExtMeshFeaturesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtMeshGpuInstancingJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtMeshGpuInstancing.h>
#include <CesiumGltfReader/ExtensionExtMeshGpuInstancingReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtMeshGpuInstancingJsonHandler::
    ExtensionExtMeshGpuInstancingJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _attributes() {}

void ExtensionExtMeshGpuInstancingJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtMeshGpuInstancing* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtMeshGpuInstancingJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtMeshGpuInstancing(
      CesiumGltf::ExtensionExtMeshGpuInstancing::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtMeshGpuInstancingJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionExtMeshGpuInstancing())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtMeshGpuInstancing&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtMeshGpuInstancingJsonHandler::
    readObjectKeyExtensionExtMeshGpuInstancing(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtMeshGpuInstancing& o) {
  using namespace std::string_literals;

  if ("attributes"s == str) {
    return property("attributes", this->_attributes, o.attributes);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtMeshGpuInstancingReader::ExtensionExtMeshGpuInstancingReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtMeshGpuInstancingReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtMeshGpuInstancingReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtMeshGpuInstancing>
ExtensionExtMeshGpuInstancingReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtMeshGpuInstancingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtMeshGpuInstancing>
ExtensionExtMeshGpuInstancingReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtMeshGpuInstancingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtMeshGpuInstancing>>
ExtensionExtMeshGpuInstancingReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtMeshGpuInstancing,
      ExtensionExtMeshGpuInstancingJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionBufferExtMeshoptCompressionJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionBufferExtMeshoptCompression.h>
#include <CesiumGltfReader/ExtensionBufferExtMeshoptCompressionReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionBufferExtMeshoptCompressionJsonHandler::
    ExtensionBufferExtMeshoptCompressionJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _fallback() {}

void ExtensionBufferExtMeshoptCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionBufferExtMeshoptCompression* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionBufferExtMeshoptCompressionJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionBufferExtMeshoptCompression(
      CesiumGltf::ExtensionBufferExtMeshoptCompression::TypeName,
      str,
      *this->_pObject);
}

void ExtensionBufferExtMeshoptCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionBufferExtMeshoptCompression())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionBufferExtMeshoptCompression&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionBufferExtMeshoptCompressionJsonHandler::
    readObjectKeyExtensionBufferExtMeshoptCompression(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionBufferExtMeshoptCompression& o) {
  using namespace std::string_literals;

  if ("fallback"s == str) {
    return property("fallback", this->_fallback, o.fallback);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionBufferExtMeshoptCompressionReader::
    ExtensionBufferExtMeshoptCompressionReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionBufferExtMeshoptCompressionReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionBufferExtMeshoptCompressionReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionBufferExtMeshoptCompression>
ExtensionBufferExtMeshoptCompressionReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionBufferExtMeshoptCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionBufferExtMeshoptCompression>
ExtensionBufferExtMeshoptCompressionReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionBufferExtMeshoptCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionBufferExtMeshoptCompression>>
ExtensionBufferExtMeshoptCompressionReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionBufferExtMeshoptCompression,
      ExtensionBufferExtMeshoptCompressionJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionBufferViewExtMeshoptCompressionJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionBufferViewExtMeshoptCompression.h>
#include <CesiumGltfReader/ExtensionBufferViewExtMeshoptCompressionReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionBufferViewExtMeshoptCompressionJsonHandler::
    ExtensionBufferViewExtMeshoptCompressionJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _buffer(),
      _byteOffset(),
      _byteLength(),
      _byteStride(),
      _count(),
      _mode(),
      _filter() {}

void ExtensionBufferViewExtMeshoptCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionBufferViewExtMeshoptCompression* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionBufferViewExtMeshoptCompressionJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionBufferViewExtMeshoptCompression(
      CesiumGltf::ExtensionBufferViewExtMeshoptCompression::TypeName,
      str,
      *this->_pObject);
}

void ExtensionBufferViewExtMeshoptCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(
              extensionName,
              CesiumGltf::ExtensionBufferViewExtMeshoptCompression())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionBufferViewExtMeshoptCompression&>(
          value));
}

CesiumJsonReader::IJsonHandler*
ExtensionBufferViewExtMeshoptCompressionJsonHandler::
    readObjectKeyExtensionBufferViewExtMeshoptCompression(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionBufferViewExtMeshoptCompression& o) {
  using namespace std::string_literals;

  if ("buffer"s == str) {
    return property("buffer", this->_buffer, o.buffer);
  }
  if ("byteOffset"s == str) {
    return property("byteOffset", this->_byteOffset, o.byteOffset);
  }
  if ("byteLength"s == str) {
    return property("byteLength", this->_byteLength, o.byteLength);
  }
  if ("byteStride"s == str) {
    return property("byteStride", this->_byteStride, o.byteStride);
  }
  if ("count"s == str) {
    return property("count", this->_count, o.count);
  }
  if ("mode"s == str) {
    return property("mode", this->_mode, o.mode);
  }
  if ("filter"s == str) {
    return property("filter", this->_filter, o.filter);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionBufferViewExtMeshoptCompressionReader::
    ExtensionBufferViewExtMeshoptCompressionReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionBufferViewExtMeshoptCompressionReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionBufferViewExtMeshoptCompressionReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionBufferViewExtMeshoptCompression>
ExtensionBufferViewExtMeshoptCompressionReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionBufferViewExtMeshoptCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionBufferViewExtMeshoptCompression>
ExtensionBufferViewExtMeshoptCompressionReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionBufferViewExtMeshoptCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionBufferViewExtMeshoptCompression>>
ExtensionBufferViewExtMeshoptCompressionReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionBufferViewExtMeshoptCompression,
      ExtensionBufferViewExtMeshoptCompressionJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtStructuralMetadataJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtStructuralMetadata.h>
#include <CesiumGltfReader/ExtensionExtStructuralMetadataReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtStructuralMetadataJsonHandler::
    ExtensionExtStructuralMetadataJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _classProperty(),
      _properties() {}

void ExtensionExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtStructuralMetadata* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtStructuralMetadataJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtStructuralMetadata(
      CesiumGltf::ExtensionExtStructuralMetadata::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionExtStructuralMetadata())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtStructuralMetadata&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtStructuralMetadataJsonHandler::
    readObjectKeyExtensionExtStructuralMetadata(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtStructuralMetadata& o) {
  using namespace std::string_literals;

  if ("class"s == str) {
    return property("class", this->_classProperty, o.classProperty);
  }
  if ("properties"s == str) {
    return property("properties", this->_properties, o.properties);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtStructuralMetadataReader::ExtensionExtStructuralMetadataReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtStructuralMetadataReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtStructuralMetadataReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtStructuralMetadata>
ExtensionExtStructuralMetadataReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtStructuralMetadataJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtStructuralMetadata>
ExtensionExtStructuralMetadataReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtStructuralMetadataJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtStructuralMetadata>>
ExtensionExtStructuralMetadataReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtStructuralMetadata,
      ExtensionExtStructuralMetadataJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionModelExtStructuralMetadataJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionModelExtStructuralMetadata.h>
#include <CesiumGltfReader/ExtensionModelExtStructuralMetadataReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionModelExtStructuralMetadataJsonHandler::
    ExtensionModelExtStructuralMetadataJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _schema(options),
      _schemaUri(),
      _propertyTables(options),
      _propertyTextures(options),
      _propertyAttributes(options) {}

void ExtensionModelExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionModelExtStructuralMetadata* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionModelExtStructuralMetadataJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionModelExtStructuralMetadata(
      CesiumGltf::ExtensionModelExtStructuralMetadata::TypeName,
      str,
      *this->_pObject);
}

void ExtensionModelExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionModelExtStructuralMetadata())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionModelExtStructuralMetadata&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionModelExtStructuralMetadataJsonHandler::
    readObjectKeyExtensionModelExtStructuralMetadata(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionModelExtStructuralMetadata& o) {
  using namespace std::string_literals;

  if ("schema"s == str) {
    return property("schema", this->_schema, o.schema);
  }
  if ("schemaUri"s == str) {
    return property("schemaUri", this->_schemaUri, o.schemaUri);
  }
  if ("propertyTables"s == str) {
    return property("propertyTables", this->_propertyTables, o.propertyTables);
  }
  if ("propertyTextures"s == str) {
    return property(
        "propertyTextures",
        this->_propertyTextures,
        o.propertyTextures);
  }
  if ("propertyAttributes"s == str) {
    return property(
        "propertyAttributes",
        this->_propertyAttributes,
        o.propertyAttributes);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionModelExtStructuralMetadataReader::
    ExtensionModelExtStructuralMetadataReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionModelExtStructuralMetadataReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionModelExtStructuralMetadataReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelExtStructuralMetadata>
ExtensionModelExtStructuralMetadataReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionModelExtStructuralMetadataJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelExtStructuralMetadata>
ExtensionModelExtStructuralMetadataReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionModelExtStructuralMetadataJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionModelExtStructuralMetadata>>
ExtensionModelExtStructuralMetadataReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionModelExtStructuralMetadata,
      ExtensionModelExtStructuralMetadataJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionMeshPrimitiveExtStructuralMetadata.h>
#include <CesiumGltfReader/ExtensionMeshPrimitiveExtStructuralMetadataReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler::
    ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _propertyTextures(),
      _propertyAttributes() {}

void ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionMeshPrimitiveExtStructuralMetadata(
      CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata::TypeName,
      str,
      *this->_pObject);
}

void ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(
              extensionName,
              CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata&>(
          value));
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler::
    readObjectKeyExtensionMeshPrimitiveExtStructuralMetadata(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata& o) {
  using namespace std::string_literals;

  if ("propertyTextures"s == str) {
    return property(
        "propertyTextures",
        this->_propertyTextures,
        o.propertyTextures);
  }
  if ("propertyAttributes"s == str) {
    return property(
        "propertyAttributes",
        this->_propertyAttributes,
        o.propertyAttributes);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionMeshPrimitiveExtStructuralMetadataReader::
    ExtensionMeshPrimitiveExtStructuralMetadataReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveExtStructuralMetadataReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveExtStructuralMetadataReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata>
ExtensionMeshPrimitiveExtStructuralMetadataReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata>
ExtensionMeshPrimitiveExtStructuralMetadataReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata>>
ExtensionMeshPrimitiveExtStructuralMetadataReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata,
      ExtensionMeshPrimitiveExtStructuralMetadataJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrDracoMeshCompressionJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrDracoMeshCompression.h>
#include <CesiumGltfReader/ExtensionKhrDracoMeshCompressionReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrDracoMeshCompressionJsonHandler::
    ExtensionKhrDracoMeshCompressionJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _bufferView(),
      _attributes() {}

void ExtensionKhrDracoMeshCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrDracoMeshCompression* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrDracoMeshCompressionJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrDracoMeshCompression(
      CesiumGltf::ExtensionKhrDracoMeshCompression::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrDracoMeshCompressionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionKhrDracoMeshCompression())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrDracoMeshCompression&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionKhrDracoMeshCompressionJsonHandler::
    readObjectKeyExtensionKhrDracoMeshCompression(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionKhrDracoMeshCompression& o) {
  using namespace std::string_literals;

  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }
  if ("attributes"s == str) {
    return property("attributes", this->_attributes, o.attributes);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrDracoMeshCompressionReader::
    ExtensionKhrDracoMeshCompressionReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrDracoMeshCompressionReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrDracoMeshCompressionReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrDracoMeshCompression>
ExtensionKhrDracoMeshCompressionReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrDracoMeshCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrDracoMeshCompression>
ExtensionKhrDracoMeshCompressionReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrDracoMeshCompressionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrDracoMeshCompression>>
ExtensionKhrDracoMeshCompressionReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrDracoMeshCompression,
      ExtensionKhrDracoMeshCompressionJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrMaterialsUnlitJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrMaterialsUnlit.h>
#include <CesiumGltfReader/ExtensionKhrMaterialsUnlitReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrMaterialsUnlitJsonHandler::ExtensionKhrMaterialsUnlitJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options) {}

void ExtensionKhrMaterialsUnlitJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrMaterialsUnlit* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrMaterialsUnlitJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrMaterialsUnlit(
      CesiumGltf::ExtensionKhrMaterialsUnlit::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrMaterialsUnlitJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionKhrMaterialsUnlit())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrMaterialsUnlit&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrMaterialsUnlitJsonHandler::readObjectKeyExtensionKhrMaterialsUnlit(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionKhrMaterialsUnlit& o) {
  using namespace std::string_literals;

  (void)o;

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrMaterialsUnlitReader::ExtensionKhrMaterialsUnlitReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrMaterialsUnlitReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrMaterialsUnlitReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrMaterialsUnlit>
ExtensionKhrMaterialsUnlitReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrMaterialsUnlitJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrMaterialsUnlit>
ExtensionKhrMaterialsUnlitReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrMaterialsUnlitJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrMaterialsUnlit>>
ExtensionKhrMaterialsUnlitReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrMaterialsUnlit,
      ExtensionKhrMaterialsUnlitJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionModelKhrMaterialsVariantsJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionModelKhrMaterialsVariants.h>
#include <CesiumGltfReader/ExtensionModelKhrMaterialsVariantsReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionModelKhrMaterialsVariantsJsonHandler::
    ExtensionModelKhrMaterialsVariantsJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _variants(options) {}

void ExtensionModelKhrMaterialsVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionModelKhrMaterialsVariants* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionModelKhrMaterialsVariantsJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionModelKhrMaterialsVariants(
      CesiumGltf::ExtensionModelKhrMaterialsVariants::TypeName,
      str,
      *this->_pObject);
}

void ExtensionModelKhrMaterialsVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionModelKhrMaterialsVariants())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionModelKhrMaterialsVariants&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionModelKhrMaterialsVariantsJsonHandler::
    readObjectKeyExtensionModelKhrMaterialsVariants(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionModelKhrMaterialsVariants& o) {
  using namespace std::string_literals;

  if ("variants"s == str) {
    return property("variants", this->_variants, o.variants);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionModelKhrMaterialsVariantsReader::
    ExtensionModelKhrMaterialsVariantsReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionModelKhrMaterialsVariantsReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionModelKhrMaterialsVariantsReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionModelKhrMaterialsVariants>
ExtensionModelKhrMaterialsVariantsReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionModelKhrMaterialsVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionModelKhrMaterialsVariants>
ExtensionModelKhrMaterialsVariantsReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionModelKhrMaterialsVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionModelKhrMaterialsVariants>>
ExtensionModelKhrMaterialsVariantsReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionModelKhrMaterialsVariants,
      ExtensionModelKhrMaterialsVariantsJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionMeshPrimitiveKhrMaterialsVariants.h>
#include <CesiumGltfReader/ExtensionMeshPrimitiveKhrMaterialsVariantsReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler::
    ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _mappings(options) {}

void ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionMeshPrimitiveKhrMaterialsVariants(
      CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants::TypeName,
      str,
      *this->_pObject);
}

void ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(
              extensionName,
              CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants&>(
          value));
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler::
    readObjectKeyExtensionMeshPrimitiveKhrMaterialsVariants(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants& o) {
  using namespace std::string_literals;

  if ("mappings"s == str) {
    return property("mappings", this->_mappings, o.mappings);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionMeshPrimitiveKhrMaterialsVariantsReader::
    ExtensionMeshPrimitiveKhrMaterialsVariantsReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveKhrMaterialsVariantsReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveKhrMaterialsVariantsReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants>
ExtensionMeshPrimitiveKhrMaterialsVariantsReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants>
ExtensionMeshPrimitiveKhrMaterialsVariantsReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants>>
ExtensionMeshPrimitiveKhrMaterialsVariantsReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariants,
      ExtensionMeshPrimitiveKhrMaterialsVariantsJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrTextureBasisuJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrTextureBasisu.h>
#include <CesiumGltfReader/ExtensionKhrTextureBasisuReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrTextureBasisuJsonHandler::ExtensionKhrTextureBasisuJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _source() {}

void ExtensionKhrTextureBasisuJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrTextureBasisu* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrTextureBasisuJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrTextureBasisu(
      CesiumGltf::ExtensionKhrTextureBasisu::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrTextureBasisuJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionKhrTextureBasisu())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrTextureBasisu&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrTextureBasisuJsonHandler::readObjectKeyExtensionKhrTextureBasisu(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionKhrTextureBasisu& o) {
  using namespace std::string_literals;

  if ("source"s == str) {
    return property("source", this->_source, o.source);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrTextureBasisuReader::ExtensionKhrTextureBasisuReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrTextureBasisuReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrTextureBasisuReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrTextureBasisu>
ExtensionKhrTextureBasisuReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrTextureBasisuJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrTextureBasisu>
ExtensionKhrTextureBasisuReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrTextureBasisuJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrTextureBasisu>>
ExtensionKhrTextureBasisuReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrTextureBasisu,
      ExtensionKhrTextureBasisuJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionModelMaxarMeshVariantsJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionModelMaxarMeshVariants.h>
#include <CesiumGltfReader/ExtensionModelMaxarMeshVariantsReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionModelMaxarMeshVariantsJsonHandler::
    ExtensionModelMaxarMeshVariantsJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _defaultProperty(),
      _variants(options) {}

void ExtensionModelMaxarMeshVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionModelMaxarMeshVariants* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionModelMaxarMeshVariantsJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionModelMaxarMeshVariants(
      CesiumGltf::ExtensionModelMaxarMeshVariants::TypeName,
      str,
      *this->_pObject);
}

void ExtensionModelMaxarMeshVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionModelMaxarMeshVariants())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionModelMaxarMeshVariants&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionModelMaxarMeshVariantsJsonHandler::
    readObjectKeyExtensionModelMaxarMeshVariants(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionModelMaxarMeshVariants& o) {
  using namespace std::string_literals;

  if ("default"s == str) {
    return property("default", this->_defaultProperty, o.defaultProperty);
  }
  if ("variants"s == str) {
    return property("variants", this->_variants, o.variants);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionModelMaxarMeshVariantsReader::ExtensionModelMaxarMeshVariantsReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionModelMaxarMeshVariantsReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionModelMaxarMeshVariantsReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionModelMaxarMeshVariants>
ExtensionModelMaxarMeshVariantsReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionModelMaxarMeshVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionModelMaxarMeshVariants>
ExtensionModelMaxarMeshVariantsReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionModelMaxarMeshVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionModelMaxarMeshVariants>>
ExtensionModelMaxarMeshVariantsReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionModelMaxarMeshVariants,
      ExtensionModelMaxarMeshVariantsJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionNodeMaxarMeshVariantsJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionNodeMaxarMeshVariants.h>
#include <CesiumGltfReader/ExtensionNodeMaxarMeshVariantsReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionNodeMaxarMeshVariantsJsonHandler::
    ExtensionNodeMaxarMeshVariantsJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _mappings(options) {}

void ExtensionNodeMaxarMeshVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionNodeMaxarMeshVariants* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionNodeMaxarMeshVariantsJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionNodeMaxarMeshVariants(
      CesiumGltf::ExtensionNodeMaxarMeshVariants::TypeName,
      str,
      *this->_pObject);
}

void ExtensionNodeMaxarMeshVariantsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionNodeMaxarMeshVariants())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionNodeMaxarMeshVariants&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionNodeMaxarMeshVariantsJsonHandler::
    readObjectKeyExtensionNodeMaxarMeshVariants(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionNodeMaxarMeshVariants& o) {
  using namespace std::string_literals;

  if ("mappings"s == str) {
    return property("mappings", this->_mappings, o.mappings);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionNodeMaxarMeshVariantsReader::ExtensionNodeMaxarMeshVariantsReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionNodeMaxarMeshVariantsReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionNodeMaxarMeshVariantsReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionNodeMaxarMeshVariants>
ExtensionNodeMaxarMeshVariantsReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionNodeMaxarMeshVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionNodeMaxarMeshVariants>
ExtensionNodeMaxarMeshVariantsReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionNodeMaxarMeshVariantsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionNodeMaxarMeshVariants>>
ExtensionNodeMaxarMeshVariantsReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionNodeMaxarMeshVariants,
      ExtensionNodeMaxarMeshVariantsJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrTextureTransformJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrTextureTransform.h>
#include <CesiumGltfReader/ExtensionKhrTextureTransformReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrTextureTransformJsonHandler::
    ExtensionKhrTextureTransformJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _offset(),
      _rotation(),
      _scale(),
      _texCoord() {}

void ExtensionKhrTextureTransformJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrTextureTransform* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrTextureTransformJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrTextureTransform(
      CesiumGltf::ExtensionKhrTextureTransform::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrTextureTransformJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionKhrTextureTransform())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrTextureTransform&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionKhrTextureTransformJsonHandler::
    readObjectKeyExtensionKhrTextureTransform(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionKhrTextureTransform& o) {
  using namespace std::string_literals;

  if ("offset"s == str) {
    return property("offset", this->_offset, o.offset);
  }
  if ("rotation"s == str) {
    return property("rotation", this->_rotation, o.rotation);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("texCoord"s == str) {
    return property("texCoord", this->_texCoord, o.texCoord);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrTextureTransformReader::ExtensionKhrTextureTransformReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrTextureTransformReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrTextureTransformReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrTextureTransform>
ExtensionKhrTextureTransformReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrTextureTransformJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrTextureTransform>
ExtensionKhrTextureTransformReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrTextureTransformJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrTextureTransform>>
ExtensionKhrTextureTransformReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrTextureTransform,
      ExtensionKhrTextureTransformJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionTextureWebpJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionTextureWebp.h>
#include <CesiumGltfReader/ExtensionTextureWebpReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionTextureWebpJsonHandler::ExtensionTextureWebpJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _source() {}

void ExtensionTextureWebpJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionTextureWebp* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionTextureWebpJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionTextureWebp(
      CesiumGltf::ExtensionTextureWebp::TypeName,
      str,
      *this->_pObject);
}

void ExtensionTextureWebpJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions.emplace(extensionName, CesiumGltf::ExtensionTextureWebp())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionTextureWebp&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionTextureWebpJsonHandler::readObjectKeyExtensionTextureWebp(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionTextureWebp& o) {
  using namespace std::string_literals;

  if ("source"s == str) {
    return property("source", this->_source, o.source);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionTextureWebpReader::ExtensionTextureWebpReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& ExtensionTextureWebpReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionTextureWebpReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionTextureWebp>
ExtensionTextureWebpReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionTextureWebpJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionTextureWebp>
ExtensionTextureWebpReader::readFromJson(const rapidjson::Value& value) const {
  ExtensionTextureWebpJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::ExtensionTextureWebp>>
ExtensionTextureWebpReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionTextureWebp,
      ExtensionTextureWebpJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionCesiumPrimitiveOutlineJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionCesiumPrimitiveOutline.h>
#include <CesiumGltfReader/ExtensionCesiumPrimitiveOutlineReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionCesiumPrimitiveOutlineJsonHandler::
    ExtensionCesiumPrimitiveOutlineJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _indices() {}

void ExtensionCesiumPrimitiveOutlineJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionCesiumPrimitiveOutline* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionCesiumPrimitiveOutlineJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionCesiumPrimitiveOutline(
      CesiumGltf::ExtensionCesiumPrimitiveOutline::TypeName,
      str,
      *this->_pObject);
}

void ExtensionCesiumPrimitiveOutlineJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionCesiumPrimitiveOutline())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionCesiumPrimitiveOutline&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionCesiumPrimitiveOutlineJsonHandler::
    readObjectKeyExtensionCesiumPrimitiveOutline(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionCesiumPrimitiveOutline& o) {
  using namespace std::string_literals;

  if ("indices"s == str) {
    return property("indices", this->_indices, o.indices);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionCesiumPrimitiveOutlineReader::ExtensionCesiumPrimitiveOutlineReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionCesiumPrimitiveOutlineReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionCesiumPrimitiveOutlineReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumPrimitiveOutline>
ExtensionCesiumPrimitiveOutlineReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionCesiumPrimitiveOutlineJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionCesiumPrimitiveOutline>
ExtensionCesiumPrimitiveOutlineReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionCesiumPrimitiveOutlineJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionCesiumPrimitiveOutline>>
ExtensionCesiumPrimitiveOutlineReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionCesiumPrimitiveOutline,
      ExtensionCesiumPrimitiveOutlineJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrImplicitShapesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrImplicitShapes.h>
#include <CesiumGltfReader/ExtensionKhrImplicitShapesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrImplicitShapesJsonHandler::ExtensionKhrImplicitShapesJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _shapes(options) {}

void ExtensionKhrImplicitShapesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrImplicitShapes* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrImplicitShapesJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrImplicitShapes(
      CesiumGltf::ExtensionKhrImplicitShapes::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrImplicitShapesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionKhrImplicitShapes())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrImplicitShapes&>(value));
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrImplicitShapesJsonHandler::readObjectKeyExtensionKhrImplicitShapes(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ExtensionKhrImplicitShapes& o) {
  using namespace std::string_literals;

  if ("shapes"s == str) {
    return property("shapes", this->_shapes, o.shapes);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrImplicitShapesReader::ExtensionKhrImplicitShapesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrImplicitShapesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrImplicitShapesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrImplicitShapes>
ExtensionKhrImplicitShapesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrImplicitShapesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrImplicitShapes>
ExtensionKhrImplicitShapesReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrImplicitShapesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrImplicitShapes>>
ExtensionKhrImplicitShapesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrImplicitShapes,
      ExtensionKhrImplicitShapesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtImplicitEllipsoidRegionJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtImplicitEllipsoidRegion.h>
#include <CesiumGltfReader/ExtensionExtImplicitEllipsoidRegionReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtImplicitEllipsoidRegionJsonHandler::
    ExtensionExtImplicitEllipsoidRegionJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _semiMajorAxisRadius(),
      _semiMinorAxisRadius(),
      _minHeight(),
      _maxHeight(),
      _minLatitude(),
      _maxLatitude(),
      _minLongitude(),
      _maxLongitude() {}

void ExtensionExtImplicitEllipsoidRegionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtImplicitEllipsoidRegion* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtImplicitEllipsoidRegionJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtImplicitEllipsoidRegion(
      CesiumGltf::ExtensionExtImplicitEllipsoidRegion::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtImplicitEllipsoidRegionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionExtImplicitEllipsoidRegion())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtImplicitEllipsoidRegion&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtImplicitEllipsoidRegionJsonHandler::
    readObjectKeyExtensionExtImplicitEllipsoidRegion(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtImplicitEllipsoidRegion& o) {
  using namespace std::string_literals;

  if ("semiMajorAxisRadius"s == str) {
    return property(
        "semiMajorAxisRadius",
        this->_semiMajorAxisRadius,
        o.semiMajorAxisRadius);
  }
  if ("semiMinorAxisRadius"s == str) {
    return property(
        "semiMinorAxisRadius",
        this->_semiMinorAxisRadius,
        o.semiMinorAxisRadius);
  }
  if ("minHeight"s == str) {
    return property("minHeight", this->_minHeight, o.minHeight);
  }
  if ("maxHeight"s == str) {
    return property("maxHeight", this->_maxHeight, o.maxHeight);
  }
  if ("minLatitude"s == str) {
    return property("minLatitude", this->_minLatitude, o.minLatitude);
  }
  if ("maxLatitude"s == str) {
    return property("maxLatitude", this->_maxLatitude, o.maxLatitude);
  }
  if ("minLongitude"s == str) {
    return property("minLongitude", this->_minLongitude, o.minLongitude);
  }
  if ("maxLongitude"s == str) {
    return property("maxLongitude", this->_maxLongitude, o.maxLongitude);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtImplicitEllipsoidRegionReader::
    ExtensionExtImplicitEllipsoidRegionReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtImplicitEllipsoidRegionReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtImplicitEllipsoidRegionReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionExtImplicitEllipsoidRegion>
ExtensionExtImplicitEllipsoidRegionReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtImplicitEllipsoidRegionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionExtImplicitEllipsoidRegion>
ExtensionExtImplicitEllipsoidRegionReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtImplicitEllipsoidRegionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtImplicitEllipsoidRegion>>
ExtensionExtImplicitEllipsoidRegionReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtImplicitEllipsoidRegion,
      ExtensionExtImplicitEllipsoidRegionJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtImplicitCylinderRegionJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtImplicitCylinderRegion.h>
#include <CesiumGltfReader/ExtensionExtImplicitCylinderRegionReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtImplicitCylinderRegionJsonHandler::
    ExtensionExtImplicitCylinderRegionJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _minRadius(),
      _maxRadius(),
      _height(),
      _minAngle(),
      _maxAngle() {}

void ExtensionExtImplicitCylinderRegionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtImplicitCylinderRegion* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtImplicitCylinderRegionJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtImplicitCylinderRegion(
      CesiumGltf::ExtensionExtImplicitCylinderRegion::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtImplicitCylinderRegionJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value = o.extensions
                        .emplace(
                            extensionName,
                            CesiumGltf::ExtensionExtImplicitCylinderRegion())
                        .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtImplicitCylinderRegion&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtImplicitCylinderRegionJsonHandler::
    readObjectKeyExtensionExtImplicitCylinderRegion(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtImplicitCylinderRegion& o) {
  using namespace std::string_literals;

  if ("minRadius"s == str) {
    return property("minRadius", this->_minRadius, o.minRadius);
  }
  if ("maxRadius"s == str) {
    return property("maxRadius", this->_maxRadius, o.maxRadius);
  }
  if ("height"s == str) {
    return property("height", this->_height, o.height);
  }
  if ("minAngle"s == str) {
    return property("minAngle", this->_minAngle, o.minAngle);
  }
  if ("maxAngle"s == str) {
    return property("maxAngle", this->_maxAngle, o.maxAngle);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtImplicitCylinderRegionReader::
    ExtensionExtImplicitCylinderRegionReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtImplicitCylinderRegionReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtImplicitCylinderRegionReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtImplicitCylinderRegion>
ExtensionExtImplicitCylinderRegionReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtImplicitCylinderRegionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtImplicitCylinderRegion>
ExtensionExtImplicitCylinderRegionReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtImplicitCylinderRegionJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtImplicitCylinderRegion>>
ExtensionExtImplicitCylinderRegionReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtImplicitCylinderRegion,
      ExtensionExtImplicitCylinderRegionJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtPrimitiveVoxelsJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtPrimitiveVoxels.h>
#include <CesiumGltfReader/ExtensionExtPrimitiveVoxelsReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtPrimitiveVoxelsJsonHandler::ExtensionExtPrimitiveVoxelsJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _shape(),
      _dimensions(),
      _padding(options),
      _noData() {}

void ExtensionExtPrimitiveVoxelsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtPrimitiveVoxels* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtPrimitiveVoxelsJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtPrimitiveVoxels(
      CesiumGltf::ExtensionExtPrimitiveVoxels::TypeName,
      str,
      *this->_pObject);
}

void ExtensionExtPrimitiveVoxelsJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionExtPrimitiveVoxels())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionExtPrimitiveVoxels&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionExtPrimitiveVoxelsJsonHandler::
    readObjectKeyExtensionExtPrimitiveVoxels(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtPrimitiveVoxels& o) {
  using namespace std::string_literals;

  if ("shape"s == str) {
    return property("shape", this->_shape, o.shape);
  }
  if ("dimensions"s == str) {
    return property("dimensions", this->_dimensions, o.dimensions);
  }
  if ("padding"s == str) {
    return property("padding", this->_padding, o.padding);
  }
  if ("noData"s == str) {
    return property("noData", this->_noData, o.noData);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtPrimitiveVoxelsReader::ExtensionExtPrimitiveVoxelsReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtPrimitiveVoxelsReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtPrimitiveVoxelsReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtPrimitiveVoxels>
ExtensionExtPrimitiveVoxelsReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtPrimitiveVoxelsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionExtPrimitiveVoxels>
ExtensionExtPrimitiveVoxelsReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtPrimitiveVoxelsJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtPrimitiveVoxels>>
ExtensionExtPrimitiveVoxelsReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtPrimitiveVoxels,
      ExtensionExtPrimitiveVoxelsJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrGaussianSplattingJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrGaussianSplatting.h>
#include <CesiumGltfReader/ExtensionKhrGaussianSplattingReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrGaussianSplattingJsonHandler::
    ExtensionKhrGaussianSplattingJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _kernel(),
      _colorSpace(),
      _projection(),
      _sortingMethod() {}

void ExtensionKhrGaussianSplattingJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrGaussianSplatting* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrGaussianSplattingJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrGaussianSplatting(
      CesiumGltf::ExtensionKhrGaussianSplatting::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrGaussianSplattingJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(extensionName, CesiumGltf::ExtensionKhrGaussianSplatting())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrGaussianSplatting&>(value));
}

CesiumJsonReader::IJsonHandler* ExtensionKhrGaussianSplattingJsonHandler::
    readObjectKeyExtensionKhrGaussianSplatting(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionKhrGaussianSplatting& o) {
  using namespace std::string_literals;

  if ("kernel"s == str) {
    return property("kernel", this->_kernel, o.kernel);
  }
  if ("colorSpace"s == str) {
    return property("colorSpace", this->_colorSpace, o.colorSpace);
  }
  if ("projection"s == str) {
    return property("projection", this->_projection, o.projection);
  }
  if ("sortingMethod"s == str) {
    return property("sortingMethod", this->_sortingMethod, o.sortingMethod);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrGaussianSplattingReader::ExtensionKhrGaussianSplattingReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrGaussianSplattingReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrGaussianSplattingReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrGaussianSplatting>
ExtensionKhrGaussianSplattingReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrGaussianSplattingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ExtensionKhrGaussianSplatting>
ExtensionKhrGaussianSplattingReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrGaussianSplattingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrGaussianSplatting>>
ExtensionKhrGaussianSplattingReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrGaussianSplatting,
      ExtensionKhrGaussianSplattingJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionKhrGaussianSplattingCompressionSpz2.h>
#include <CesiumGltfReader/ExtensionKhrGaussianSplattingCompressionSpz2Reader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/ExtensibleObject.h>

#include <rapidjson/document.h>

#include <any>
#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler::
    ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _bufferView() {}

void ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionKhrGaussianSplattingCompressionSpz2(
      CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2::TypeName,
      str,
      *this->_pObject);
}

void ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumUtility::ExtensibleObject& o,
    const std::string_view& extensionName) {
  std::any& value =
      o.extensions
          .emplace(
              extensionName,
              CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2())
          .first->second;
  this->reset(
      pParentHandler,
      &std::any_cast<CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2&>(
          value));
}

CesiumJsonReader::IJsonHandler*
ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler::
    readObjectKeyExtensionKhrGaussianSplattingCompressionSpz2(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2& o) {
  using namespace std::string_literals;

  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionKhrGaussianSplattingCompressionSpz2Reader::
    ExtensionKhrGaussianSplattingCompressionSpz2Reader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionKhrGaussianSplattingCompressionSpz2Reader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionKhrGaussianSplattingCompressionSpz2Reader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2>
ExtensionKhrGaussianSplattingCompressionSpz2Reader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2>
ExtensionKhrGaussianSplattingCompressionSpz2Reader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2>>
ExtensionKhrGaussianSplattingCompressionSpz2Reader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionKhrGaussianSplattingCompressionSpz2,
      ExtensionKhrGaussianSplattingCompressionSpz2JsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PaddingJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Padding.h>
#include <CesiumGltfReader/PaddingReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PaddingJsonHandler::PaddingJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _before(),
      _after() {}

void PaddingJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Padding* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PaddingJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPadding(
      CesiumGltf::Padding::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* PaddingJsonHandler::readObjectKeyPadding(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Padding& o) {
  using namespace std::string_literals;

  if ("before"s == str) {
    return property("before", this->_before, o.before);
  }
  if ("after"s == str) {
    return property("after", this->_after, o.after);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PaddingReader::PaddingReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& PaddingReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& PaddingReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Padding>
PaddingReader::readFromJson(const std::span<const std::byte>& data) const {
  PaddingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Padding>
PaddingReader::readFromJson(const rapidjson::Value& value) const {
  PaddingJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Padding>>
PaddingReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Padding, PaddingJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "ShapeJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Shape.h>
#include <CesiumGltfReader/ShapeReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ShapeJsonHandler::ShapeJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _type(),
      _sphere(options),
      _box(options),
      _capsule(options),
      _cylinder(options) {}

void ShapeJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Shape* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ShapeJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyShape(
      CesiumGltf::Shape::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* ShapeJsonHandler::readObjectKeyShape(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Shape& o) {
  using namespace std::string_literals;

  if ("type"s == str) {
    return property("type", this->_type, o.type);
  }
  if ("sphere"s == str) {
    return property("sphere", this->_sphere, o.sphere);
  }
  if ("box"s == str) {
    return property("box", this->_box, o.box);
  }
  if ("capsule"s == str) {
    return property("capsule", this->_capsule, o.capsule);
  }
  if ("cylinder"s == str) {
    return property("cylinder", this->_cylinder, o.cylinder);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

ShapeReader::ShapeReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& ShapeReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& ShapeReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Shape>
ShapeReader::readFromJson(const std::span<const std::byte>& data) const {
  ShapeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Shape>
ShapeReader::readFromJson(const rapidjson::Value& value) const {
  ShapeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Shape>>
ShapeReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Shape, ShapeJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "CylinderJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Cylinder.h>
#include <CesiumGltfReader/CylinderReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

CylinderJsonHandler::CylinderJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _height(),
      _radiusBottom(),
      _radiusTop() {}

void CylinderJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Cylinder* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
CylinderJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyCylinder(
      CesiumGltf::Cylinder::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* CylinderJsonHandler::readObjectKeyCylinder(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Cylinder& o) {
  using namespace std::string_literals;

  if ("height"s == str) {
    return property("height", this->_height, o.height);
  }
  if ("radiusBottom"s == str) {
    return property("radiusBottom", this->_radiusBottom, o.radiusBottom);
  }
  if ("radiusTop"s == str) {
    return property("radiusTop", this->_radiusTop, o.radiusTop);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

CylinderReader::CylinderReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& CylinderReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& CylinderReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Cylinder>
CylinderReader::readFromJson(const std::span<const std::byte>& data) const {
  CylinderJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Cylinder>
CylinderReader::readFromJson(const rapidjson::Value& value) const {
  CylinderJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Cylinder>>
CylinderReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Cylinder, CylinderJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "CapsuleJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Capsule.h>
#include <CesiumGltfReader/CapsuleReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

CapsuleJsonHandler::CapsuleJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _height(),
      _radiusBottom(),
      _radiusTop() {}

void CapsuleJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Capsule* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
CapsuleJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyCapsule(
      CesiumGltf::Capsule::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* CapsuleJsonHandler::readObjectKeyCapsule(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Capsule& o) {
  using namespace std::string_literals;

  if ("height"s == str) {
    return property("height", this->_height, o.height);
  }
  if ("radiusBottom"s == str) {
    return property("radiusBottom", this->_radiusBottom, o.radiusBottom);
  }
  if ("radiusTop"s == str) {
    return property("radiusTop", this->_radiusTop, o.radiusTop);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

CapsuleReader::CapsuleReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& CapsuleReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& CapsuleReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Capsule>
CapsuleReader::readFromJson(const std::span<const std::byte>& data) const {
  CapsuleJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Capsule>
CapsuleReader::readFromJson(const rapidjson::Value& value) const {
  CapsuleJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Capsule>>
CapsuleReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Capsule, CapsuleJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "BoxJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Box.h>
#include <CesiumGltfReader/BoxReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

BoxJsonHandler::BoxJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _size() {}

void BoxJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Box* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
BoxJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyBox(
      CesiumGltf::Box::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* BoxJsonHandler::readObjectKeyBox(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Box& o) {
  using namespace std::string_literals;

  if ("size"s == str) {
    return property("size", this->_size, o.size);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

BoxReader::BoxReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& BoxReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& BoxReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Box>
BoxReader::readFromJson(const std::span<const std::byte>& data) const {
  BoxJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Box>
BoxReader::readFromJson(const rapidjson::Value& value) const {
  BoxJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Box>>
BoxReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Box, BoxJsonHandler> handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "SphereJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Sphere.h>
#include <CesiumGltfReader/SphereReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

SphereJsonHandler::SphereJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options), _radius() {}

void SphereJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Sphere* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
SphereJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeySphere(
      CesiumGltf::Sphere::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* SphereJsonHandler::readObjectKeySphere(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Sphere& o) {
  using namespace std::string_literals;

  if ("radius"s == str) {
    return property("radius", this->_radius, o.radius);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

SphereReader::SphereReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& SphereReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& SphereReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Sphere>
SphereReader::readFromJson(const std::span<const std::byte>& data) const {
  SphereJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Sphere>
SphereReader::readFromJson(const rapidjson::Value& value) const {
  SphereJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Sphere>>
SphereReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Sphere, SphereJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionNodeMaxarMeshVariantsMappingsValue.h>
#include <CesiumGltfReader/ExtensionNodeMaxarMeshVariantsMappingsValueReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler::
    ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _variants(),
      _mesh(),
      _name() {}

void ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionNodeMaxarMeshVariantsMappingsValue(
      CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler::
    readObjectKeyExtensionNodeMaxarMeshVariantsMappingsValue(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue& o) {
  using namespace std::string_literals;

  if ("variants"s == str) {
    return property("variants", this->_variants, o.variants);
  }
  if ("mesh"s == str) {
    return property("mesh", this->_mesh, o.mesh);
  }
  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionNodeMaxarMeshVariantsMappingsValueReader::
    ExtensionNodeMaxarMeshVariantsMappingsValueReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionNodeMaxarMeshVariantsMappingsValueReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionNodeMaxarMeshVariantsMappingsValueReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue>
ExtensionNodeMaxarMeshVariantsMappingsValueReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue>
ExtensionNodeMaxarMeshVariantsMappingsValueReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue>>
ExtensionNodeMaxarMeshVariantsMappingsValueReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionNodeMaxarMeshVariantsMappingsValue,
      ExtensionNodeMaxarMeshVariantsMappingsValueJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionModelMaxarMeshVariantsValueJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionModelMaxarMeshVariantsValue.h>
#include <CesiumGltfReader/ExtensionModelMaxarMeshVariantsValueReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionModelMaxarMeshVariantsValueJsonHandler::
    ExtensionModelMaxarMeshVariantsValueJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options), _name() {}

void ExtensionModelMaxarMeshVariantsValueJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionModelMaxarMeshVariantsValue* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionModelMaxarMeshVariantsValueJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionModelMaxarMeshVariantsValue(
      CesiumGltf::ExtensionModelMaxarMeshVariantsValue::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ExtensionModelMaxarMeshVariantsValueJsonHandler::
    readObjectKeyExtensionModelMaxarMeshVariantsValue(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionModelMaxarMeshVariantsValue& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

ExtensionModelMaxarMeshVariantsValueReader::
    ExtensionModelMaxarMeshVariantsValueReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionModelMaxarMeshVariantsValueReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionModelMaxarMeshVariantsValueReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelMaxarMeshVariantsValue>
ExtensionModelMaxarMeshVariantsValueReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionModelMaxarMeshVariantsValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelMaxarMeshVariantsValue>
ExtensionModelMaxarMeshVariantsValueReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionModelMaxarMeshVariantsValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionModelMaxarMeshVariantsValue>>
ExtensionModelMaxarMeshVariantsValueReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionModelMaxarMeshVariantsValue,
      ExtensionModelMaxarMeshVariantsValueJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue.h>
#include <CesiumGltfReader/ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler::
    ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _variants(),
      _material(),
      _name() {}

void ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue*
        pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler::
    readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this
      ->readObjectKeyExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue(
          CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue::
              TypeName,
          str,
          *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler::
    readObjectKeyExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue&
            o) {
  using namespace std::string_literals;

  if ("variants"s == str) {
    return property("variants", this->_variants, o.variants);
  }
  if ("material"s == str) {
    return property("material", this->_material, o.material);
  }
  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::
    ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::getOptions()
    const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue>
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue>
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<
    CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue>>
ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueReader::
    readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValue,
      ExtensionMeshPrimitiveKhrMaterialsVariantsMappingsValueJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionModelKhrMaterialsVariantsValueJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionModelKhrMaterialsVariantsValue.h>
#include <CesiumGltfReader/ExtensionModelKhrMaterialsVariantsValueReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionModelKhrMaterialsVariantsValueJsonHandler::
    ExtensionModelKhrMaterialsVariantsValueJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options), _name() {}

void ExtensionModelKhrMaterialsVariantsValueJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionModelKhrMaterialsVariantsValue* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionModelKhrMaterialsVariantsValueJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionModelKhrMaterialsVariantsValue(
      CesiumGltf::ExtensionModelKhrMaterialsVariantsValue::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ExtensionModelKhrMaterialsVariantsValueJsonHandler::
    readObjectKeyExtensionModelKhrMaterialsVariantsValue(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionModelKhrMaterialsVariantsValue& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

ExtensionModelKhrMaterialsVariantsValueReader::
    ExtensionModelKhrMaterialsVariantsValueReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionModelKhrMaterialsVariantsValueReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionModelKhrMaterialsVariantsValueReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelKhrMaterialsVariantsValue>
ExtensionModelKhrMaterialsVariantsValueReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionModelKhrMaterialsVariantsValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionModelKhrMaterialsVariantsValue>
ExtensionModelKhrMaterialsVariantsValueReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionModelKhrMaterialsVariantsValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionModelKhrMaterialsVariantsValue>>
ExtensionModelKhrMaterialsVariantsValueReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionModelKhrMaterialsVariantsValue,
      ExtensionModelKhrMaterialsVariantsValueJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyAttributeJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyAttribute.h>
#include <CesiumGltfReader/PropertyAttributeReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyAttributeJsonHandler::PropertyAttributeJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _classProperty(),
      _properties(options) {}

void PropertyAttributeJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyAttribute* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyAttributeJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyAttribute(
      CesiumGltf::PropertyAttribute::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyAttributeJsonHandler::readObjectKeyPropertyAttribute(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyAttribute& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("class"s == str) {
    return property("class", this->_classProperty, o.classProperty);
  }
  if ("properties"s == str) {
    return property("properties", this->_properties, o.properties);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PropertyAttributeReader::PropertyAttributeReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& PropertyAttributeReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyAttributeReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyAttribute>
PropertyAttributeReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyAttributeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyAttribute>
PropertyAttributeReader::readFromJson(const rapidjson::Value& value) const {
  PropertyAttributeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::PropertyAttribute>>
PropertyAttributeReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::PropertyAttribute,
      PropertyAttributeJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyAttributePropertyJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyAttributeProperty.h>
#include <CesiumGltfReader/PropertyAttributePropertyReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyAttributePropertyJsonHandler::PropertyAttributePropertyJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _attribute(),
      _offset(),
      _scale(),
      _max(),
      _min() {}

void PropertyAttributePropertyJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyAttributeProperty* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyAttributePropertyJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyAttributeProperty(
      CesiumGltf::PropertyAttributeProperty::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyAttributePropertyJsonHandler::readObjectKeyPropertyAttributeProperty(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyAttributeProperty& o) {
  using namespace std::string_literals;

  if ("attribute"s == str) {
    return property("attribute", this->_attribute, o.attribute);
  }
  if ("offset"s == str) {
    return property("offset", this->_offset, o.offset);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("max"s == str) {
    return property("max", this->_max, o.max);
  }
  if ("min"s == str) {
    return property("min", this->_min, o.min);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PropertyAttributePropertyReader::PropertyAttributePropertyReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
PropertyAttributePropertyReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyAttributePropertyReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyAttributeProperty>
PropertyAttributePropertyReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyAttributePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyAttributeProperty>
PropertyAttributePropertyReader::readFromJson(
    const rapidjson::Value& value) const {
  PropertyAttributePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::PropertyAttributeProperty>>
PropertyAttributePropertyReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::PropertyAttributeProperty,
      PropertyAttributePropertyJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyTextureJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyTexture.h>
#include <CesiumGltfReader/PropertyTextureReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyTextureJsonHandler::PropertyTextureJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _classProperty(),
      _properties(options) {}

void PropertyTextureJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyTexture* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyTextureJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyTexture(
      CesiumGltf::PropertyTexture::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyTextureJsonHandler::readObjectKeyPropertyTexture(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyTexture& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("class"s == str) {
    return property("class", this->_classProperty, o.classProperty);
  }
  if ("properties"s == str) {
    return property("properties", this->_properties, o.properties);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PropertyTextureReader::PropertyTextureReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& PropertyTextureReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyTextureReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTexture>
PropertyTextureReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyTextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTexture>
PropertyTextureReader::readFromJson(const rapidjson::Value& value) const {
  PropertyTextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::PropertyTexture>>
PropertyTextureReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::PropertyTexture, PropertyTextureJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyTexturePropertyJsonHandler.h"
#include "TextureInfoJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyTextureProperty.h>
#include <CesiumGltfReader/PropertyTexturePropertyReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyTexturePropertyJsonHandler::PropertyTexturePropertyJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : TextureInfoJsonHandler(options),
      _channels(),
      _offset(),
      _scale(),
      _max(),
      _min() {}

void PropertyTexturePropertyJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyTextureProperty* pObject) {
  TextureInfoJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyTexturePropertyJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyTextureProperty(
      CesiumGltf::PropertyTextureProperty::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyTexturePropertyJsonHandler::readObjectKeyPropertyTextureProperty(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyTextureProperty& o) {
  using namespace std::string_literals;

  if ("channels"s == str) {
    return property("channels", this->_channels, o.channels);
  }
  if ("offset"s == str) {
    return property("offset", this->_offset, o.offset);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("max"s == str) {
    return property("max", this->_max, o.max);
  }
  if ("min"s == str) {
    return property("min", this->_min, o.min);
  }

  return this->readObjectKeyTextureInfo(objectType, str, *this->_pObject);
}

PropertyTexturePropertyReader::PropertyTexturePropertyReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
PropertyTexturePropertyReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyTexturePropertyReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTextureProperty>
PropertyTexturePropertyReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyTexturePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTextureProperty>
PropertyTexturePropertyReader::readFromJson(
    const rapidjson::Value& value) const {
  PropertyTexturePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::PropertyTextureProperty>>
PropertyTexturePropertyReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::PropertyTextureProperty,
      PropertyTexturePropertyJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "TextureInfoJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/TextureInfo.h>
#include <CesiumGltfReader/TextureInfoReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

TextureInfoJsonHandler::TextureInfoJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _index(),
      _texCoord() {}

void TextureInfoJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::TextureInfo* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
TextureInfoJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyTextureInfo(
      CesiumGltf::TextureInfo::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
TextureInfoJsonHandler::readObjectKeyTextureInfo(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::TextureInfo& o) {
  using namespace std::string_literals;

  if ("index"s == str) {
    return property("index", this->_index, o.index);
  }
  if ("texCoord"s == str) {
    return property("texCoord", this->_texCoord, o.texCoord);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

TextureInfoReader::TextureInfoReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& TextureInfoReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
TextureInfoReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::TextureInfo>
TextureInfoReader::readFromJson(const std::span<const std::byte>& data) const {
  TextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::TextureInfo>
TextureInfoReader::readFromJson(const rapidjson::Value& value) const {
  TextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::TextureInfo>>
TextureInfoReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::TextureInfo, TextureInfoJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyTableJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyTable.h>
#include <CesiumGltfReader/PropertyTableReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyTableJsonHandler::PropertyTableJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _classProperty(),
      _count(),
      _properties(options) {}

void PropertyTableJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyTable* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyTableJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyTable(
      CesiumGltf::PropertyTable::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyTableJsonHandler::readObjectKeyPropertyTable(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyTable& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("class"s == str) {
    return property("class", this->_classProperty, o.classProperty);
  }
  if ("count"s == str) {
    return property("count", this->_count, o.count);
  }
  if ("properties"s == str) {
    return property("properties", this->_properties, o.properties);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PropertyTableReader::PropertyTableReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& PropertyTableReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyTableReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTable>
PropertyTableReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyTableJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTable>
PropertyTableReader::readFromJson(const rapidjson::Value& value) const {
  PropertyTableJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::PropertyTable>>
PropertyTableReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::PropertyTable, PropertyTableJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "PropertyTablePropertyJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/PropertyTableProperty.h>
#include <CesiumGltfReader/PropertyTablePropertyReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

PropertyTablePropertyJsonHandler::PropertyTablePropertyJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _values(),
      _arrayOffsets(),
      _stringOffsets(),
      _arrayOffsetType(),
      _stringOffsetType(),
      _offset(),
      _scale(),
      _max(),
      _min() {}

void PropertyTablePropertyJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::PropertyTableProperty* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
PropertyTablePropertyJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyPropertyTableProperty(
      CesiumGltf::PropertyTableProperty::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
PropertyTablePropertyJsonHandler::readObjectKeyPropertyTableProperty(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::PropertyTableProperty& o) {
  using namespace std::string_literals;

  if ("values"s == str) {
    return property("values", this->_values, o.values);
  }
  if ("arrayOffsets"s == str) {
    return property("arrayOffsets", this->_arrayOffsets, o.arrayOffsets);
  }
  if ("stringOffsets"s == str) {
    return property("stringOffsets", this->_stringOffsets, o.stringOffsets);
  }
  if ("arrayOffsetType"s == str) {
    return property(
        "arrayOffsetType",
        this->_arrayOffsetType,
        o.arrayOffsetType);
  }
  if ("stringOffsetType"s == str) {
    return property(
        "stringOffsetType",
        this->_stringOffsetType,
        o.stringOffsetType);
  }
  if ("offset"s == str) {
    return property("offset", this->_offset, o.offset);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("max"s == str) {
    return property("max", this->_max, o.max);
  }
  if ("min"s == str) {
    return property("min", this->_min, o.min);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

PropertyTablePropertyReader::PropertyTablePropertyReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& PropertyTablePropertyReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
PropertyTablePropertyReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTableProperty>
PropertyTablePropertyReader::readFromJson(
    const std::span<const std::byte>& data) const {
  PropertyTablePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::PropertyTableProperty>
PropertyTablePropertyReader::readFromJson(const rapidjson::Value& value) const {
  PropertyTablePropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::PropertyTableProperty>>
PropertyTablePropertyReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::PropertyTableProperty,
      PropertyTablePropertyJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "SchemaJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Schema.h>
#include <CesiumGltfReader/SchemaReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumJsonReader/SharedAssetJsonHandler.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

SchemaJsonHandler::SchemaJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::SharedAssetJsonHandler(options),
      _id(),
      _name(),
      _description(),
      _version(),
      _classes(options),
      _enums(options) {}

void SchemaJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Schema* pObject) {
  CesiumJsonReader::SharedAssetJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
SchemaJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeySchema(
      CesiumGltf::Schema::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* SchemaJsonHandler::readObjectKeySchema(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Schema& o) {
  using namespace std::string_literals;

  if ("id"s == str) {
    return property("id", this->_id, o.id);
  }
  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("description"s == str) {
    return property("description", this->_description, o.description);
  }
  if ("version"s == str) {
    return property("version", this->_version, o.version);
  }
  if ("classes"s == str) {
    return property("classes", this->_classes, o.classes);
  }
  if ("enums"s == str) {
    return property("enums", this->_enums, o.enums);
  }

  return this->readObjectKeySharedAsset(objectType, str, *this->_pObject);
}

SchemaReader::SchemaReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& SchemaReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& SchemaReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Schema>
SchemaReader::readFromJson(const std::span<const std::byte>& data) const {
  SchemaJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Schema>
SchemaReader::readFromJson(const rapidjson::Value& value) const {
  SchemaJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Schema>>
SchemaReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Schema, SchemaJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "EnumJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Enum.h>
#include <CesiumGltfReader/EnumReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

EnumJsonHandler::EnumJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _description(),
      _valueType(),
      _values(options) {}

void EnumJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Enum* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
EnumJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyEnum(
      CesiumGltf::Enum::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* EnumJsonHandler::readObjectKeyEnum(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Enum& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("description"s == str) {
    return property("description", this->_description, o.description);
  }
  if ("valueType"s == str) {
    return property("valueType", this->_valueType, o.valueType);
  }
  if ("values"s == str) {
    return property("values", this->_values, o.values);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

EnumReader::EnumReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& EnumReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& EnumReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Enum>
EnumReader::readFromJson(const std::span<const std::byte>& data) const {
  EnumJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Enum>
EnumReader::readFromJson(const rapidjson::Value& value) const {
  EnumJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Enum>>
EnumReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Enum, EnumJsonHandler> handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "EnumValueJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/EnumValue.h>
#include <CesiumGltfReader/EnumValueReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

EnumValueJsonHandler::EnumValueJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _description(),
      _value() {}

void EnumValueJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::EnumValue* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
EnumValueJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyEnumValue(
      CesiumGltf::EnumValue::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* EnumValueJsonHandler::readObjectKeyEnumValue(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::EnumValue& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("description"s == str) {
    return property("description", this->_description, o.description);
  }
  if ("value"s == str) {
    return property("value", this->_value, o.value);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

EnumValueReader::EnumValueReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& EnumValueReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& EnumValueReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::EnumValue>
EnumValueReader::readFromJson(const std::span<const std::byte>& data) const {
  EnumValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::EnumValue>
EnumValueReader::readFromJson(const rapidjson::Value& value) const {
  EnumValueJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::EnumValue>>
EnumValueReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::EnumValue, EnumValueJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ClassJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Class.h>
#include <CesiumGltfReader/ClassReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ClassJsonHandler::ClassJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _description(),
      _properties(options),
      _parent() {}

void ClassJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Class* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ClassJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyClass(
      CesiumGltf::Class::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* ClassJsonHandler::readObjectKeyClass(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Class& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("description"s == str) {
    return property("description", this->_description, o.description);
  }
  if ("properties"s == str) {
    return property("properties", this->_properties, o.properties);
  }
  if ("parent"s == str) {
    return property("parent", this->_parent, o.parent);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ClassReader::ClassReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& ClassReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& ClassReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Class>
ClassReader::readFromJson(const std::span<const std::byte>& data) const {
  ClassJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Class>
ClassReader::readFromJson(const rapidjson::Value& value) const {
  ClassJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Class>>
ClassReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Class, ClassJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ClassPropertyJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ClassProperty.h>
#include <CesiumGltfReader/ClassPropertyReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ClassPropertyJsonHandler::ClassPropertyJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _name(),
      _description(),
      _type(),
      _componentType(),
      _enumType(),
      _array(),
      _count(),
      _normalized(),
      _offset(),
      _scale(),
      _max(),
      _min(),
      _required(),
      _noData(),
      _defaultProperty(),
      _semantic() {}

void ClassPropertyJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ClassProperty* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ClassPropertyJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyClassProperty(
      CesiumGltf::ClassProperty::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ClassPropertyJsonHandler::readObjectKeyClassProperty(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::ClassProperty& o) {
  using namespace std::string_literals;

  if ("name"s == str) {
    return property("name", this->_name, o.name);
  }
  if ("description"s == str) {
    return property("description", this->_description, o.description);
  }
  if ("type"s == str) {
    return property("type", this->_type, o.type);
  }
  if ("componentType"s == str) {
    return property("componentType", this->_componentType, o.componentType);
  }
  if ("enumType"s == str) {
    return property("enumType", this->_enumType, o.enumType);
  }
  if ("array"s == str) {
    return property("array", this->_array, o.array);
  }
  if ("count"s == str) {
    return property("count", this->_count, o.count);
  }
  if ("normalized"s == str) {
    return property("normalized", this->_normalized, o.normalized);
  }
  if ("offset"s == str) {
    return property("offset", this->_offset, o.offset);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("max"s == str) {
    return property("max", this->_max, o.max);
  }
  if ("min"s == str) {
    return property("min", this->_min, o.min);
  }
  if ("required"s == str) {
    return property("required", this->_required, o.required);
  }
  if ("noData"s == str) {
    return property("noData", this->_noData, o.noData);
  }
  if ("default"s == str) {
    return property("default", this->_defaultProperty, o.defaultProperty);
  }
  if ("semantic"s == str) {
    return property("semantic", this->_semantic, o.semantic);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ClassPropertyReader::ClassPropertyReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& ClassPropertyReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ClassPropertyReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ClassProperty>
ClassPropertyReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ClassPropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::ClassProperty>
ClassPropertyReader::readFromJson(const rapidjson::Value& value) const {
  ClassPropertyJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::ClassProperty>>
ClassPropertyReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::ClassProperty, ClassPropertyJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "FeatureIdJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/FeatureId.h>
#include <CesiumGltfReader/FeatureIdReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

FeatureIdJsonHandler::FeatureIdJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _featureCount(),
      _nullFeatureId(),
      _label(),
      _attribute(),
      _texture(options),
      _propertyTable() {}

void FeatureIdJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::FeatureId* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
FeatureIdJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyFeatureId(
      CesiumGltf::FeatureId::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* FeatureIdJsonHandler::readObjectKeyFeatureId(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::FeatureId& o) {
  using namespace std::string_literals;

  if ("featureCount"s == str) {
    return property("featureCount", this->_featureCount, o.featureCount);
  }
  if ("nullFeatureId"s == str) {
    return property("nullFeatureId", this->_nullFeatureId, o.nullFeatureId);
  }
  if ("label"s == str) {
    return property("label", this->_label, o.label);
  }
  if ("attribute"s == str) {
    return property("attribute", this->_attribute, o.attribute);
  }
  if ("texture"s == str) {
    return property("texture", this->_texture, o.texture);
  }
  if ("propertyTable"s == str) {
    return property("propertyTable", this->_propertyTable, o.propertyTable);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

FeatureIdReader::FeatureIdReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& FeatureIdReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& FeatureIdReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::FeatureId>
FeatureIdReader::readFromJson(const std::span<const std::byte>& data) const {
  FeatureIdJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::FeatureId>
FeatureIdReader::readFromJson(const rapidjson::Value& value) const {
  FeatureIdJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::FeatureId>>
FeatureIdReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::FeatureId, FeatureIdJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "FeatureIdTextureJsonHandler.h"
#include "TextureInfoJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/FeatureIdTexture.h>
#include <CesiumGltfReader/FeatureIdTextureReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

FeatureIdTextureJsonHandler::FeatureIdTextureJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : TextureInfoJsonHandler(options), _channels() {}

void FeatureIdTextureJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::FeatureIdTexture* pObject) {
  TextureInfoJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
FeatureIdTextureJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyFeatureIdTexture(
      CesiumGltf::FeatureIdTexture::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
FeatureIdTextureJsonHandler::readObjectKeyFeatureIdTexture(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::FeatureIdTexture& o) {
  using namespace std::string_literals;

  if ("channels"s == str) {
    return property("channels", this->_channels, o.channels);
  }

  return this->readObjectKeyTextureInfo(objectType, str, *this->_pObject);
}

FeatureIdTextureReader::FeatureIdTextureReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& FeatureIdTextureReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
FeatureIdTextureReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::FeatureIdTexture>
FeatureIdTextureReader::readFromJson(
    const std::span<const std::byte>& data) const {
  FeatureIdTextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::FeatureIdTexture>
FeatureIdTextureReader::readFromJson(const rapidjson::Value& value) const {
  FeatureIdTextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::FeatureIdTexture>>
FeatureIdTextureReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::FeatureIdTexture,
      FeatureIdTextureJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ExtensionExtInstanceFeaturesFeatureIdJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/ExtensionExtInstanceFeaturesFeatureId.h>
#include <CesiumGltfReader/ExtensionExtInstanceFeaturesFeatureIdReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ExtensionExtInstanceFeaturesFeatureIdJsonHandler::
    ExtensionExtInstanceFeaturesFeatureIdJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _featureCount(),
      _nullFeatureId(),
      _label(),
      _attribute(),
      _propertyTable() {}

void ExtensionExtInstanceFeaturesFeatureIdJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::ExtensionExtInstanceFeaturesFeatureId* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ExtensionExtInstanceFeaturesFeatureIdJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyExtensionExtInstanceFeaturesFeatureId(
      CesiumGltf::ExtensionExtInstanceFeaturesFeatureId::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
ExtensionExtInstanceFeaturesFeatureIdJsonHandler::
    readObjectKeyExtensionExtInstanceFeaturesFeatureId(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::ExtensionExtInstanceFeaturesFeatureId& o) {
  using namespace std::string_literals;

  if ("featureCount"s == str) {
    return property("featureCount", this->_featureCount, o.featureCount);
  }
  if ("nullFeatureId"s == str) {
    return property("nullFeatureId", this->_nullFeatureId, o.nullFeatureId);
  }
  if ("label"s == str) {
    return property("label", this->_label, o.label);
  }
  if ("attribute"s == str) {
    return property("attribute", this->_attribute, o.attribute);
  }
  if ("propertyTable"s == str) {
    return property("propertyTable", this->_propertyTable, o.propertyTable);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ExtensionExtInstanceFeaturesFeatureIdReader::
    ExtensionExtInstanceFeaturesFeatureIdReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
ExtensionExtInstanceFeaturesFeatureIdReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
ExtensionExtInstanceFeaturesFeatureIdReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionExtInstanceFeaturesFeatureId>
ExtensionExtInstanceFeaturesFeatureIdReader::readFromJson(
    const std::span<const std::byte>& data) const {
  ExtensionExtInstanceFeaturesFeatureIdJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<
    CesiumGltf::ExtensionExtInstanceFeaturesFeatureId>
ExtensionExtInstanceFeaturesFeatureIdReader::readFromJson(
    const rapidjson::Value& value) const {
  ExtensionExtInstanceFeaturesFeatureIdJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::ExtensionExtInstanceFeaturesFeatureId>>
ExtensionExtInstanceFeaturesFeatureIdReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::ExtensionExtInstanceFeaturesFeatureId,
      ExtensionExtInstanceFeaturesFeatureIdJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ModelJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Model.h>
#include <CesiumGltfReader/ModelReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ModelJsonHandler::ModelJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _extensionsUsed(),
      _extensionsRequired(),
      _accessors(options),
      _animations(options),
      _asset(options),
      _buffers(options),
      _bufferViews(options),
      _cameras(options),
      _images(options),
      _materials(options),
      _meshes(options),
      _nodes(options),
      _samplers(options),
      _scene(),
      _scenes(options),
      _skins(options),
      _textures(options) {}

void ModelJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Model* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ModelJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyModel(
      CesiumGltf::Model::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* ModelJsonHandler::readObjectKeyModel(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Model& o) {
  using namespace std::string_literals;

  if ("extensionsUsed"s == str) {
    return property("extensionsUsed", this->_extensionsUsed, o.extensionsUsed);
  }
  if ("extensionsRequired"s == str) {
    return property(
        "extensionsRequired",
        this->_extensionsRequired,
        o.extensionsRequired);
  }
  if ("accessors"s == str) {
    return property("accessors", this->_accessors, o.accessors);
  }
  if ("animations"s == str) {
    return property("animations", this->_animations, o.animations);
  }
  if ("asset"s == str) {
    return property("asset", this->_asset, o.asset);
  }
  if ("buffers"s == str) {
    return property("buffers", this->_buffers, o.buffers);
  }
  if ("bufferViews"s == str) {
    return property("bufferViews", this->_bufferViews, o.bufferViews);
  }
  if ("cameras"s == str) {
    return property("cameras", this->_cameras, o.cameras);
  }
  if ("images"s == str) {
    return property("images", this->_images, o.images);
  }
  if ("materials"s == str) {
    return property("materials", this->_materials, o.materials);
  }
  if ("meshes"s == str) {
    return property("meshes", this->_meshes, o.meshes);
  }
  if ("nodes"s == str) {
    return property("nodes", this->_nodes, o.nodes);
  }
  if ("samplers"s == str) {
    return property("samplers", this->_samplers, o.samplers);
  }
  if ("scene"s == str) {
    return property("scene", this->_scene, o.scene);
  }
  if ("scenes"s == str) {
    return property("scenes", this->_scenes, o.scenes);
  }
  if ("skins"s == str) {
    return property("skins", this->_skins, o.skins);
  }
  if ("textures"s == str) {
    return property("textures", this->_textures, o.textures);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

ModelReader::ModelReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& ModelReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& ModelReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Model>
ModelReader::readFromJson(const std::span<const std::byte>& data) const {
  ModelJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Model>
ModelReader::readFromJson(const rapidjson::Value& value) const {
  ModelJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Model>>
ModelReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Model, ModelJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "TextureJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Texture.h>
#include <CesiumGltfReader/TextureReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

TextureJsonHandler::TextureJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _sampler(),
      _source() {}

void TextureJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Texture* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
TextureJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyTexture(
      CesiumGltf::Texture::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* TextureJsonHandler::readObjectKeyTexture(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Texture& o) {
  using namespace std::string_literals;

  if ("sampler"s == str) {
    return property("sampler", this->_sampler, o.sampler);
  }
  if ("source"s == str) {
    return property("source", this->_source, o.source);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

TextureReader::TextureReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& TextureReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& TextureReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Texture>
TextureReader::readFromJson(const std::span<const std::byte>& data) const {
  TextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Texture>
TextureReader::readFromJson(const rapidjson::Value& value) const {
  TextureJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Texture>>
TextureReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Texture, TextureJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "SkinJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Skin.h>
#include <CesiumGltfReader/SkinReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

SkinJsonHandler::SkinJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _inverseBindMatrices(),
      _skeleton(),
      _joints() {}

void SkinJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Skin* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
SkinJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeySkin(
      CesiumGltf::Skin::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* SkinJsonHandler::readObjectKeySkin(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Skin& o) {
  using namespace std::string_literals;

  if ("inverseBindMatrices"s == str) {
    return property(
        "inverseBindMatrices",
        this->_inverseBindMatrices,
        o.inverseBindMatrices);
  }
  if ("skeleton"s == str) {
    return property("skeleton", this->_skeleton, o.skeleton);
  }
  if ("joints"s == str) {
    return property("joints", this->_joints, o.joints);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

SkinReader::SkinReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& SkinReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& SkinReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Skin>
SkinReader::readFromJson(const std::span<const std::byte>& data) const {
  SkinJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Skin>
SkinReader::readFromJson(const rapidjson::Value& value) const {
  SkinJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Skin>>
SkinReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Skin, SkinJsonHandler> handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "SceneJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Scene.h>
#include <CesiumGltfReader/SceneReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

SceneJsonHandler::SceneJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options), _nodes() {}

void SceneJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Scene* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
SceneJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyScene(
      CesiumGltf::Scene::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* SceneJsonHandler::readObjectKeyScene(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Scene& o) {
  using namespace std::string_literals;

  if ("nodes"s == str) {
    return property("nodes", this->_nodes, o.nodes);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

SceneReader::SceneReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& SceneReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& SceneReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Scene>
SceneReader::readFromJson(const std::span<const std::byte>& data) const {
  SceneJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Scene>
SceneReader::readFromJson(const rapidjson::Value& value) const {
  SceneJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Scene>>
SceneReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Scene, SceneJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "SamplerJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Sampler.h>
#include <CesiumGltfReader/SamplerReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

SamplerJsonHandler::SamplerJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _magFilter(),
      _minFilter(),
      _wrapS(),
      _wrapT() {}

void SamplerJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Sampler* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
SamplerJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeySampler(
      CesiumGltf::Sampler::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* SamplerJsonHandler::readObjectKeySampler(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Sampler& o) {
  using namespace std::string_literals;

  if ("magFilter"s == str) {
    return property("magFilter", this->_magFilter, o.magFilter);
  }
  if ("minFilter"s == str) {
    return property("minFilter", this->_minFilter, o.minFilter);
  }
  if ("wrapS"s == str) {
    return property("wrapS", this->_wrapS, o.wrapS);
  }
  if ("wrapT"s == str) {
    return property("wrapT", this->_wrapT, o.wrapT);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

SamplerReader::SamplerReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& SamplerReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& SamplerReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Sampler>
SamplerReader::readFromJson(const std::span<const std::byte>& data) const {
  SamplerJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Sampler>
SamplerReader::readFromJson(const rapidjson::Value& value) const {
  SamplerJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Sampler>>
SamplerReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Sampler, SamplerJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "NamedObjectJsonHandler.h"
#include "NodeJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Node.h>
#include <CesiumGltfReader/NodeReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

NodeJsonHandler::NodeJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _camera(),
      _children(),
      _skin(),
      _matrix(),
      _mesh(),
      _rotation(),
      _scale(),
      _translation(),
      _weights() {}

void NodeJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Node* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
NodeJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyNode(
      CesiumGltf::Node::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* NodeJsonHandler::readObjectKeyNode(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Node& o) {
  using namespace std::string_literals;

  if ("camera"s == str) {
    return property("camera", this->_camera, o.camera);
  }
  if ("children"s == str) {
    return property("children", this->_children, o.children);
  }
  if ("skin"s == str) {
    return property("skin", this->_skin, o.skin);
  }
  if ("matrix"s == str) {
    return property("matrix", this->_matrix, o.matrix);
  }
  if ("mesh"s == str) {
    return property("mesh", this->_mesh, o.mesh);
  }
  if ("rotation"s == str) {
    return property("rotation", this->_rotation, o.rotation);
  }
  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }
  if ("translation"s == str) {
    return property("translation", this->_translation, o.translation);
  }
  if ("weights"s == str) {
    return property("weights", this->_weights, o.weights);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

NodeReader::NodeReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& NodeReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& NodeReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Node>
NodeReader::readFromJson(const std::span<const std::byte>& data) const {
  NodeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Node>
NodeReader::readFromJson(const rapidjson::Value& value) const {
  NodeJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Node>>
NodeReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Node, NodeJsonHandler> handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MeshJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Mesh.h>
#include <CesiumGltfReader/MeshReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MeshJsonHandler::MeshJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _primitives(options),
      _weights() {}

void MeshJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Mesh* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MeshJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMesh(
      CesiumGltf::Mesh::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* MeshJsonHandler::readObjectKeyMesh(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Mesh& o) {
  using namespace std::string_literals;

  if ("primitives"s == str) {
    return property("primitives", this->_primitives, o.primitives);
  }
  if ("weights"s == str) {
    return property("weights", this->_weights, o.weights);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

MeshReader::MeshReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& MeshReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& MeshReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Mesh>
MeshReader::readFromJson(const std::span<const std::byte>& data) const {
  MeshJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Mesh>
MeshReader::readFromJson(const rapidjson::Value& value) const {
  MeshJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Mesh>>
MeshReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Mesh, MeshJsonHandler> handler(
      this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MeshPrimitiveJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/MeshPrimitive.h>
#include <CesiumGltfReader/MeshPrimitiveReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MeshPrimitiveJsonHandler::MeshPrimitiveJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _attributes(),
      _indices(),
      _material(),
      _mode(),
      _targets() {}

void MeshPrimitiveJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::MeshPrimitive* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MeshPrimitiveJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMeshPrimitive(
      CesiumGltf::MeshPrimitive::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
MeshPrimitiveJsonHandler::readObjectKeyMeshPrimitive(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::MeshPrimitive& o) {
  using namespace std::string_literals;

  if ("attributes"s == str) {
    return property("attributes", this->_attributes, o.attributes);
  }
  if ("indices"s == str) {
    return property("indices", this->_indices, o.indices);
  }
  if ("material"s == str) {
    return property("material", this->_material, o.material);
  }
  if ("mode"s == str) {
    return property("mode", this->_mode, o.mode);
  }
  if ("targets"s == str) {
    return property("targets", this->_targets, o.targets);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

MeshPrimitiveReader::MeshPrimitiveReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& MeshPrimitiveReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
MeshPrimitiveReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MeshPrimitive>
MeshPrimitiveReader::readFromJson(
    const std::span<const std::byte>& data) const {
  MeshPrimitiveJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MeshPrimitive>
MeshPrimitiveReader::readFromJson(const rapidjson::Value& value) const {
  MeshPrimitiveJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::MeshPrimitive>>
MeshPrimitiveReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::MeshPrimitive, MeshPrimitiveJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MaterialJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Material.h>
#include <CesiumGltfReader/MaterialReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MaterialJsonHandler::MaterialJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _pbrMetallicRoughness(options),
      _normalTexture(options),
      _occlusionTexture(options),
      _emissiveTexture(options),
      _emissiveFactor(),
      _alphaMode(),
      _alphaCutoff(),
      _doubleSided() {}

void MaterialJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Material* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MaterialJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMaterial(
      CesiumGltf::Material::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* MaterialJsonHandler::readObjectKeyMaterial(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Material& o) {
  using namespace std::string_literals;

  if ("pbrMetallicRoughness"s == str) {
    return property(
        "pbrMetallicRoughness",
        this->_pbrMetallicRoughness,
        o.pbrMetallicRoughness);
  }
  if ("normalTexture"s == str) {
    return property("normalTexture", this->_normalTexture, o.normalTexture);
  }
  if ("occlusionTexture"s == str) {
    return property(
        "occlusionTexture",
        this->_occlusionTexture,
        o.occlusionTexture);
  }
  if ("emissiveTexture"s == str) {
    return property(
        "emissiveTexture",
        this->_emissiveTexture,
        o.emissiveTexture);
  }
  if ("emissiveFactor"s == str) {
    return property("emissiveFactor", this->_emissiveFactor, o.emissiveFactor);
  }
  if ("alphaMode"s == str) {
    return property("alphaMode", this->_alphaMode, o.alphaMode);
  }
  if ("alphaCutoff"s == str) {
    return property("alphaCutoff", this->_alphaCutoff, o.alphaCutoff);
  }
  if ("doubleSided"s == str) {
    return property("doubleSided", this->_doubleSided, o.doubleSided);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

MaterialReader::MaterialReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& MaterialReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& MaterialReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Material>
MaterialReader::readFromJson(const std::span<const std::byte>& data) const {
  MaterialJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Material>
MaterialReader::readFromJson(const rapidjson::Value& value) const {
  MaterialJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Material>>
MaterialReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Material, MaterialJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MaterialOcclusionTextureInfoJsonHandler.h"
#include "TextureInfoJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/MaterialOcclusionTextureInfo.h>
#include <CesiumGltfReader/MaterialOcclusionTextureInfoReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MaterialOcclusionTextureInfoJsonHandler::
    MaterialOcclusionTextureInfoJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : TextureInfoJsonHandler(options), _strength() {}

void MaterialOcclusionTextureInfoJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::MaterialOcclusionTextureInfo* pObject) {
  TextureInfoJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MaterialOcclusionTextureInfoJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMaterialOcclusionTextureInfo(
      CesiumGltf::MaterialOcclusionTextureInfo::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* MaterialOcclusionTextureInfoJsonHandler::
    readObjectKeyMaterialOcclusionTextureInfo(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::MaterialOcclusionTextureInfo& o) {
  using namespace std::string_literals;

  if ("strength"s == str) {
    return property("strength", this->_strength, o.strength);
  }

  return this->readObjectKeyTextureInfo(objectType, str, *this->_pObject);
}

MaterialOcclusionTextureInfoReader::MaterialOcclusionTextureInfoReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
MaterialOcclusionTextureInfoReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
MaterialOcclusionTextureInfoReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialOcclusionTextureInfo>
MaterialOcclusionTextureInfoReader::readFromJson(
    const std::span<const std::byte>& data) const {
  MaterialOcclusionTextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialOcclusionTextureInfo>
MaterialOcclusionTextureInfoReader::readFromJson(
    const rapidjson::Value& value) const {
  MaterialOcclusionTextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::MaterialOcclusionTextureInfo>>
MaterialOcclusionTextureInfoReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::MaterialOcclusionTextureInfo,
      MaterialOcclusionTextureInfoJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MaterialNormalTextureInfoJsonHandler.h"
#include "TextureInfoJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/MaterialNormalTextureInfo.h>
#include <CesiumGltfReader/MaterialNormalTextureInfoReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MaterialNormalTextureInfoJsonHandler::MaterialNormalTextureInfoJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : TextureInfoJsonHandler(options), _scale() {}

void MaterialNormalTextureInfoJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::MaterialNormalTextureInfo* pObject) {
  TextureInfoJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MaterialNormalTextureInfoJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMaterialNormalTextureInfo(
      CesiumGltf::MaterialNormalTextureInfo::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
MaterialNormalTextureInfoJsonHandler::readObjectKeyMaterialNormalTextureInfo(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::MaterialNormalTextureInfo& o) {
  using namespace std::string_literals;

  if ("scale"s == str) {
    return property("scale", this->_scale, o.scale);
  }

  return this->readObjectKeyTextureInfo(objectType, str, *this->_pObject);
}

MaterialNormalTextureInfoReader::MaterialNormalTextureInfoReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
MaterialNormalTextureInfoReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
MaterialNormalTextureInfoReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialNormalTextureInfo>
MaterialNormalTextureInfoReader::readFromJson(
    const std::span<const std::byte>& data) const {
  MaterialNormalTextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialNormalTextureInfo>
MaterialNormalTextureInfoReader::readFromJson(
    const rapidjson::Value& value) const {
  MaterialNormalTextureInfoJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::MaterialNormalTextureInfo>>
MaterialNormalTextureInfoReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::MaterialNormalTextureInfo,
      MaterialNormalTextureInfoJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "MaterialPBRMetallicRoughnessJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/MaterialPBRMetallicRoughness.h>
#include <CesiumGltfReader/MaterialPBRMetallicRoughnessReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

MaterialPBRMetallicRoughnessJsonHandler::
    MaterialPBRMetallicRoughnessJsonHandler(
        const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _baseColorFactor(),
      _baseColorTexture(options),
      _metallicFactor(),
      _roughnessFactor(),
      _metallicRoughnessTexture(options) {}

void MaterialPBRMetallicRoughnessJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::MaterialPBRMetallicRoughness* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
MaterialPBRMetallicRoughnessJsonHandler::readObjectKey(
    const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyMaterialPBRMetallicRoughness(
      CesiumGltf::MaterialPBRMetallicRoughness::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* MaterialPBRMetallicRoughnessJsonHandler::
    readObjectKeyMaterialPBRMetallicRoughness(
        const std::string& objectType,
        const std::string_view& str,
        CesiumGltf::MaterialPBRMetallicRoughness& o) {
  using namespace std::string_literals;

  if ("baseColorFactor"s == str) {
    return property(
        "baseColorFactor",
        this->_baseColorFactor,
        o.baseColorFactor);
  }
  if ("baseColorTexture"s == str) {
    return property(
        "baseColorTexture",
        this->_baseColorTexture,
        o.baseColorTexture);
  }
  if ("metallicFactor"s == str) {
    return property("metallicFactor", this->_metallicFactor, o.metallicFactor);
  }
  if ("roughnessFactor"s == str) {
    return property(
        "roughnessFactor",
        this->_roughnessFactor,
        o.roughnessFactor);
  }
  if ("metallicRoughnessTexture"s == str) {
    return property(
        "metallicRoughnessTexture",
        this->_metallicRoughnessTexture,
        o.metallicRoughnessTexture);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

MaterialPBRMetallicRoughnessReader::MaterialPBRMetallicRoughnessReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
MaterialPBRMetallicRoughnessReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
MaterialPBRMetallicRoughnessReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialPBRMetallicRoughness>
MaterialPBRMetallicRoughnessReader::readFromJson(
    const std::span<const std::byte>& data) const {
  MaterialPBRMetallicRoughnessJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::MaterialPBRMetallicRoughness>
MaterialPBRMetallicRoughnessReader::readFromJson(
    const rapidjson::Value& value) const {
  MaterialPBRMetallicRoughnessJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::MaterialPBRMetallicRoughness>>
MaterialPBRMetallicRoughnessReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::MaterialPBRMetallicRoughness,
      MaterialPBRMetallicRoughnessJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "ImageJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Image.h>
#include <CesiumGltfReader/ImageReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

ImageJsonHandler::ImageJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _uri(),
      _mimeType(),
      _bufferView() {}

void ImageJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Image* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
ImageJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyImage(
      CesiumGltf::Image::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* ImageJsonHandler::readObjectKeyImage(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Image& o) {
  using namespace std::string_literals;

  if ("uri"s == str) {
    return property("uri", this->_uri, o.uri);
  }
  if ("mimeType"s == str) {
    return property("mimeType", this->_mimeType, o.mimeType);
  }
  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

ImageReader::ImageReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& ImageReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& ImageReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Image>
ImageReader::readFromJson(const std::span<const std::byte>& data) const {
  ImageJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Image>
ImageReader::readFromJson(const rapidjson::Value& value) const {
  ImageJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Image>>
ImageReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Image, ImageJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "CameraJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Camera.h>
#include <CesiumGltfReader/CameraReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

CameraJsonHandler::CameraJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _orthographic(options),
      _perspective(options),
      _type() {}

void CameraJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Camera* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
CameraJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyCamera(
      CesiumGltf::Camera::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* CameraJsonHandler::readObjectKeyCamera(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Camera& o) {
  using namespace std::string_literals;

  if ("orthographic"s == str) {
    return property("orthographic", this->_orthographic, o.orthographic);
  }
  if ("perspective"s == str) {
    return property("perspective", this->_perspective, o.perspective);
  }
  if ("type"s == str) {
    return property("type", this->_type, o.type);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

CameraReader::CameraReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& CameraReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& CameraReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Camera>
CameraReader::readFromJson(const std::span<const std::byte>& data) const {
  CameraJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Camera>
CameraReader::readFromJson(const rapidjson::Value& value) const {
  CameraJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Camera>>
CameraReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Camera, CameraJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "CameraPerspectiveJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/CameraPerspective.h>
#include <CesiumGltfReader/CameraPerspectiveReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

CameraPerspectiveJsonHandler::CameraPerspectiveJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _aspectRatio(),
      _yfov(),
      _zfar(),
      _znear() {}

void CameraPerspectiveJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::CameraPerspective* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
CameraPerspectiveJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyCameraPerspective(
      CesiumGltf::CameraPerspective::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
CameraPerspectiveJsonHandler::readObjectKeyCameraPerspective(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::CameraPerspective& o) {
  using namespace std::string_literals;

  if ("aspectRatio"s == str) {
    return property("aspectRatio", this->_aspectRatio, o.aspectRatio);
  }
  if ("yfov"s == str) {
    return property("yfov", this->_yfov, o.yfov);
  }
  if ("zfar"s == str) {
    return property("zfar", this->_zfar, o.zfar);
  }
  if ("znear"s == str) {
    return property("znear", this->_znear, o.znear);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

CameraPerspectiveReader::CameraPerspectiveReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& CameraPerspectiveReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
CameraPerspectiveReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::CameraPerspective>
CameraPerspectiveReader::readFromJson(
    const std::span<const std::byte>& data) const {
  CameraPerspectiveJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::CameraPerspective>
CameraPerspectiveReader::readFromJson(const rapidjson::Value& value) const {
  CameraPerspectiveJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::CameraPerspective>>
CameraPerspectiveReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::CameraPerspective,
      CameraPerspectiveJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "CameraOrthographicJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/CameraOrthographic.h>
#include <CesiumGltfReader/CameraOrthographicReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

CameraOrthographicJsonHandler::CameraOrthographicJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _xmag(),
      _ymag(),
      _zfar(),
      _znear() {}

void CameraOrthographicJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::CameraOrthographic* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
CameraOrthographicJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyCameraOrthographic(
      CesiumGltf::CameraOrthographic::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
CameraOrthographicJsonHandler::readObjectKeyCameraOrthographic(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::CameraOrthographic& o) {
  using namespace std::string_literals;

  if ("xmag"s == str) {
    return property("xmag", this->_xmag, o.xmag);
  }
  if ("ymag"s == str) {
    return property("ymag", this->_ymag, o.ymag);
  }
  if ("zfar"s == str) {
    return property("zfar", this->_zfar, o.zfar);
  }
  if ("znear"s == str) {
    return property("znear", this->_znear, o.znear);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

CameraOrthographicReader::CameraOrthographicReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& CameraOrthographicReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
CameraOrthographicReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::CameraOrthographic>
CameraOrthographicReader::readFromJson(
    const std::span<const std::byte>& data) const {
  CameraOrthographicJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::CameraOrthographic>
CameraOrthographicReader::readFromJson(const rapidjson::Value& value) const {
  CameraOrthographicJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::CameraOrthographic>>
CameraOrthographicReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::CameraOrthographic,
      CameraOrthographicJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "BufferViewJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/BufferView.h>
#include <CesiumGltfReader/BufferViewReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

BufferViewJsonHandler::BufferViewJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _buffer(),
      _byteOffset(),
      _byteLength(),
      _byteStride(),
      _target() {}

void BufferViewJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::BufferView* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
BufferViewJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyBufferView(
      CesiumGltf::BufferView::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* BufferViewJsonHandler::readObjectKeyBufferView(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::BufferView& o) {
  using namespace std::string_literals;

  if ("buffer"s == str) {
    return property("buffer", this->_buffer, o.buffer);
  }
  if ("byteOffset"s == str) {
    return property("byteOffset", this->_byteOffset, o.byteOffset);
  }
  if ("byteLength"s == str) {
    return property("byteLength", this->_byteLength, o.byteLength);
  }
  if ("byteStride"s == str) {
    return property("byteStride", this->_byteStride, o.byteStride);
  }
  if ("target"s == str) {
    return property("target", this->_target, o.target);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

BufferViewReader::BufferViewReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& BufferViewReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
BufferViewReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::BufferView>
BufferViewReader::readFromJson(const std::span<const std::byte>& data) const {
  BufferViewJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::BufferView>
BufferViewReader::readFromJson(const rapidjson::Value& value) const {
  BufferViewJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::BufferView>>
BufferViewReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::BufferView, BufferViewJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "BufferJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Buffer.h>
#include <CesiumGltfReader/BufferReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

BufferJsonHandler::BufferJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _uri(),
      _byteLength() {}

void BufferJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Buffer* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
BufferJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyBuffer(
      CesiumGltf::Buffer::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* BufferJsonHandler::readObjectKeyBuffer(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Buffer& o) {
  using namespace std::string_literals;

  if ("uri"s == str) {
    return property("uri", this->_uri, o.uri);
  }
  if ("byteLength"s == str) {
    return property("byteLength", this->_byteLength, o.byteLength);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

BufferReader::BufferReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& BufferReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& BufferReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Buffer>
BufferReader::readFromJson(const std::span<const std::byte>& data) const {
  BufferJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Buffer>
BufferReader::readFromJson(const rapidjson::Value& value) const {
  BufferJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Buffer>>
BufferReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Buffer, BufferJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AssetJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Asset.h>
#include <CesiumGltfReader/AssetReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AssetJsonHandler::AssetJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _copyright(),
      _generator(),
      _version(),
      _minVersion() {}

void AssetJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Asset* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AssetJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAsset(
      CesiumGltf::Asset::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* AssetJsonHandler::readObjectKeyAsset(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Asset& o) {
  using namespace std::string_literals;

  if ("copyright"s == str) {
    return property("copyright", this->_copyright, o.copyright);
  }
  if ("generator"s == str) {
    return property("generator", this->_generator, o.generator);
  }
  if ("version"s == str) {
    return property("version", this->_version, o.version);
  }
  if ("minVersion"s == str) {
    return property("minVersion", this->_minVersion, o.minVersion);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AssetReader::AssetReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& AssetReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& AssetReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Asset>
AssetReader::readFromJson(const std::span<const std::byte>& data) const {
  AssetJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Asset>
AssetReader::readFromJson(const rapidjson::Value& value) const {
  AssetJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Asset>>
AssetReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Asset, AssetJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AnimationJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Animation.h>
#include <CesiumGltfReader/AnimationReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AnimationJsonHandler::AnimationJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _channels(options),
      _samplers(options) {}

void AnimationJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Animation* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AnimationJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAnimation(
      CesiumGltf::Animation::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* AnimationJsonHandler::readObjectKeyAnimation(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Animation& o) {
  using namespace std::string_literals;

  if ("channels"s == str) {
    return property("channels", this->_channels, o.channels);
  }
  if ("samplers"s == str) {
    return property("samplers", this->_samplers, o.samplers);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

AnimationReader::AnimationReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& AnimationReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& AnimationReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Animation>
AnimationReader::readFromJson(const std::span<const std::byte>& data) const {
  AnimationJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Animation>
AnimationReader::readFromJson(const rapidjson::Value& value) const {
  AnimationJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Animation>>
AnimationReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::Animation, AnimationJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AnimationSamplerJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AnimationSampler.h>
#include <CesiumGltfReader/AnimationSamplerReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AnimationSamplerJsonHandler::AnimationSamplerJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _input(),
      _interpolation(),
      _output() {}

void AnimationSamplerJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AnimationSampler* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AnimationSamplerJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAnimationSampler(
      CesiumGltf::AnimationSampler::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AnimationSamplerJsonHandler::readObjectKeyAnimationSampler(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AnimationSampler& o) {
  using namespace std::string_literals;

  if ("input"s == str) {
    return property("input", this->_input, o.input);
  }
  if ("interpolation"s == str) {
    return property("interpolation", this->_interpolation, o.interpolation);
  }
  if ("output"s == str) {
    return property("output", this->_output, o.output);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AnimationSamplerReader::AnimationSamplerReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& AnimationSamplerReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AnimationSamplerReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationSampler>
AnimationSamplerReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AnimationSamplerJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationSampler>
AnimationSamplerReader::readFromJson(const rapidjson::Value& value) const {
  AnimationSamplerJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::AnimationSampler>>
AnimationSamplerReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::AnimationSampler,
      AnimationSamplerJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AnimationChannelJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AnimationChannel.h>
#include <CesiumGltfReader/AnimationChannelReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AnimationChannelJsonHandler::AnimationChannelJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _sampler(),
      _target(options) {}

void AnimationChannelJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AnimationChannel* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AnimationChannelJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAnimationChannel(
      CesiumGltf::AnimationChannel::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AnimationChannelJsonHandler::readObjectKeyAnimationChannel(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AnimationChannel& o) {
  using namespace std::string_literals;

  if ("sampler"s == str) {
    return property("sampler", this->_sampler, o.sampler);
  }
  if ("target"s == str) {
    return property("target", this->_target, o.target);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AnimationChannelReader::AnimationChannelReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& AnimationChannelReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AnimationChannelReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationChannel>
AnimationChannelReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AnimationChannelJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationChannel>
AnimationChannelReader::readFromJson(const rapidjson::Value& value) const {
  AnimationChannelJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::AnimationChannel>>
AnimationChannelReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::AnimationChannel,
      AnimationChannelJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AnimationChannelTargetJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AnimationChannelTarget.h>
#include <CesiumGltfReader/AnimationChannelTargetReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AnimationChannelTargetJsonHandler::AnimationChannelTargetJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _node(),
      _path() {}

void AnimationChannelTargetJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AnimationChannelTarget* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AnimationChannelTargetJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAnimationChannelTarget(
      CesiumGltf::AnimationChannelTarget::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AnimationChannelTargetJsonHandler::readObjectKeyAnimationChannelTarget(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AnimationChannelTarget& o) {
  using namespace std::string_literals;

  if ("node"s == str) {
    return property("node", this->_node, o.node);
  }
  if ("path"s == str) {
    return property("path", this->_path, o.path);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AnimationChannelTargetReader::AnimationChannelTargetReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions&
AnimationChannelTargetReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AnimationChannelTargetReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationChannelTarget>
AnimationChannelTargetReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AnimationChannelTargetJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AnimationChannelTarget>
AnimationChannelTargetReader::readFromJson(
    const rapidjson::Value& value) const {
  AnimationChannelTargetJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<
    std::vector<CesiumGltf::AnimationChannelTarget>>
AnimationChannelTargetReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::AnimationChannelTarget,
      AnimationChannelTargetJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AccessorJsonHandler.h"
#include "NamedObjectJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/Accessor.h>
#include <CesiumGltfReader/AccessorReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AccessorJsonHandler::AccessorJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumGltfReader::NamedObjectJsonHandler(options),
      _bufferView(),
      _byteOffset(),
      _componentType(),
      _normalized(),
      _count(),
      _type(),
      _max(),
      _min(),
      _sparse(options) {}

void AccessorJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::Accessor* pObject) {
  CesiumGltfReader::NamedObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AccessorJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAccessor(
      CesiumGltf::Accessor::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler* AccessorJsonHandler::readObjectKeyAccessor(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::Accessor& o) {
  using namespace std::string_literals;

  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }
  if ("byteOffset"s == str) {
    return property("byteOffset", this->_byteOffset, o.byteOffset);
  }
  if ("componentType"s == str) {
    return property("componentType", this->_componentType, o.componentType);
  }
  if ("normalized"s == str) {
    return property("normalized", this->_normalized, o.normalized);
  }
  if ("count"s == str) {
    return property("count", this->_count, o.count);
  }
  if ("type"s == str) {
    return property("type", this->_type, o.type);
  }
  if ("max"s == str) {
    return property("max", this->_max, o.max);
  }
  if ("min"s == str) {
    return property("min", this->_min, o.min);
  }
  if ("sparse"s == str) {
    return property("sparse", this->_sparse, o.sparse);
  }

  return this->readObjectKeyNamedObject(objectType, str, *this->_pObject);
}

AccessorReader::AccessorReader() { registerReaderExtensions(this->_options); }

CesiumJsonReader::JsonReaderOptions& AccessorReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions& AccessorReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Accessor>
AccessorReader::readFromJson(const std::span<const std::byte>& data) const {
  AccessorJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::Accessor>
AccessorReader::readFromJson(const rapidjson::Value& value) const {
  AccessorJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::Accessor>>
AccessorReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<CesiumGltf::Accessor, AccessorJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AccessorSparseJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AccessorSparse.h>
#include <CesiumGltfReader/AccessorSparseReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AccessorSparseJsonHandler::AccessorSparseJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _count(),
      _indices(options),
      _values(options) {}

void AccessorSparseJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AccessorSparse* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AccessorSparseJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAccessorSparse(
      CesiumGltf::AccessorSparse::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AccessorSparseJsonHandler::readObjectKeyAccessorSparse(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AccessorSparse& o) {
  using namespace std::string_literals;

  if ("count"s == str) {
    return property("count", this->_count, o.count);
  }
  if ("indices"s == str) {
    return property("indices", this->_indices, o.indices);
  }
  if ("values"s == str) {
    return property("values", this->_values, o.values);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AccessorSparseReader::AccessorSparseReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& AccessorSparseReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AccessorSparseReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparse>
AccessorSparseReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AccessorSparseJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparse>
AccessorSparseReader::readFromJson(const rapidjson::Value& value) const {
  AccessorSparseJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::AccessorSparse>>
AccessorSparseReader::readArrayFromJson(const rapidjson::Value& value) const {
  CesiumJsonReader::
      ArrayJsonHandler<CesiumGltf::AccessorSparse, AccessorSparseJsonHandler>
          handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AccessorSparseValuesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AccessorSparseValues.h>
#include <CesiumGltfReader/AccessorSparseValuesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AccessorSparseValuesJsonHandler::AccessorSparseValuesJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _bufferView(),
      _byteOffset() {}

void AccessorSparseValuesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AccessorSparseValues* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AccessorSparseValuesJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAccessorSparseValues(
      CesiumGltf::AccessorSparseValues::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AccessorSparseValuesJsonHandler::readObjectKeyAccessorSparseValues(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AccessorSparseValues& o) {
  using namespace std::string_literals;

  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }
  if ("byteOffset"s == str) {
    return property("byteOffset", this->_byteOffset, o.byteOffset);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AccessorSparseValuesReader::AccessorSparseValuesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& AccessorSparseValuesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AccessorSparseValuesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparseValues>
AccessorSparseValuesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AccessorSparseValuesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparseValues>
AccessorSparseValuesReader::readFromJson(const rapidjson::Value& value) const {
  AccessorSparseValuesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::AccessorSparseValues>>
AccessorSparseValuesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::AccessorSparseValues,
      AccessorSparseValuesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader
// This file was generated by generate-classes.
// DO NOT EDIT THIS FILE!
// NOLINTBEGIN(readability-duplicate-include)
#include "AccessorSparseIndicesJsonHandler.h"
#include "registerReaderExtensions.h"

#include <CesiumGltf/AccessorSparseIndices.h>
#include <CesiumGltfReader/AccessorSparseIndicesReader.h>
#include <CesiumJsonReader/ArrayJsonHandler.h>
#include <CesiumJsonReader/ExtensibleObjectJsonHandler.h>
#include <CesiumJsonReader/IJsonHandler.h>
#include <CesiumJsonReader/JsonReader.h>
#include <CesiumUtility/Assert.h>

#include <rapidjson/document.h>

#include <cstddef>
#include <span>
#include <string>
#include <string_view>
#include <vector>
// NOLINTEND(readability-duplicate-include)

namespace CesiumGltfReader {

AccessorSparseIndicesJsonHandler::AccessorSparseIndicesJsonHandler(
    const CesiumJsonReader::JsonReaderOptions& options) noexcept
    : CesiumJsonReader::ExtensibleObjectJsonHandler(options),
      _bufferView(),
      _byteOffset(),
      _componentType() {}

void AccessorSparseIndicesJsonHandler::reset(
    CesiumJsonReader::IJsonHandler* pParentHandler,
    CesiumGltf::AccessorSparseIndices* pObject) {
  CesiumJsonReader::ExtensibleObjectJsonHandler::reset(pParentHandler, pObject);
  this->_pObject = pObject;
}

CesiumJsonReader::IJsonHandler*
AccessorSparseIndicesJsonHandler::readObjectKey(const std::string_view& str) {
  CESIUM_ASSERT(this->_pObject);
  return this->readObjectKeyAccessorSparseIndices(
      CesiumGltf::AccessorSparseIndices::TypeName,
      str,
      *this->_pObject);
}

CesiumJsonReader::IJsonHandler*
AccessorSparseIndicesJsonHandler::readObjectKeyAccessorSparseIndices(
    const std::string& objectType,
    const std::string_view& str,
    CesiumGltf::AccessorSparseIndices& o) {
  using namespace std::string_literals;

  if ("bufferView"s == str) {
    return property("bufferView", this->_bufferView, o.bufferView);
  }
  if ("byteOffset"s == str) {
    return property("byteOffset", this->_byteOffset, o.byteOffset);
  }
  if ("componentType"s == str) {
    return property("componentType", this->_componentType, o.componentType);
  }

  return this->readObjectKeyExtensibleObject(objectType, str, *this->_pObject);
}

AccessorSparseIndicesReader::AccessorSparseIndicesReader() {
  registerReaderExtensions(this->_options);
}

CesiumJsonReader::JsonReaderOptions& AccessorSparseIndicesReader::getOptions() {
  return this->_options;
}

const CesiumJsonReader::JsonReaderOptions&
AccessorSparseIndicesReader::getOptions() const {
  return this->_options;
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparseIndices>
AccessorSparseIndicesReader::readFromJson(
    const std::span<const std::byte>& data) const {
  AccessorSparseIndicesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(data, handler);
}

CesiumJsonReader::ReadJsonResult<CesiumGltf::AccessorSparseIndices>
AccessorSparseIndicesReader::readFromJson(const rapidjson::Value& value) const {
  AccessorSparseIndicesJsonHandler handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

CesiumJsonReader::ReadJsonResult<std::vector<CesiumGltf::AccessorSparseIndices>>
AccessorSparseIndicesReader::readArrayFromJson(
    const rapidjson::Value& value) const {
  CesiumJsonReader::ArrayJsonHandler<
      CesiumGltf::AccessorSparseIndices,
      AccessorSparseIndicesJsonHandler>
      handler(this->_options);
  return CesiumJsonReader::JsonReader::readJson(value, handler);
}

} // namespace CesiumGltfReader