mujoco

// Copyright 2025 DeepMind Technologies Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// DO NOT EDIT. THIS FILE IS AUTOMATICALLY GENERATED.

// NOLINTBEGIN(whitespace/line_length)
// NOLINTBEGIN(whitespace/semicolon)

#ifndef MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_
#define MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_

#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/em_asm.h>
#include <emscripten/val.h>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>  // NOLINT
#include <memory>
#include <optional>  // NOLINT
#include <sstream>
#include <string>  // NOLINT
#include <string_view>
#include <vector>

#include <mujoco/mjmodel.h>
#include <mujoco/mjspec.h>
#include <mujoco/mjvisualize.h>
#include <mujoco/mujoco.h>
#include "engine/engine_util_errmem.h"
#include "wasm/unpack.h"
#include "python/mujoco/indexer_xmacro.h"

namespace mujoco::wasm {

using emscripten::enum_;
using emscripten::function;
using emscripten::typed_memory_view;
using emscripten::val;
using emscripten::return_value_policy::reference;
using emscripten::return_value_policy::take_ownership;

EMSCRIPTEN_DECLARE_VAL_TYPE(NumberOrString);
EMSCRIPTEN_DECLARE_VAL_TYPE(NumberArray);
EMSCRIPTEN_DECLARE_VAL_TYPE(String);
EMSCRIPTEN_DECLARE_VAL_TYPE(StringOrNull);

// Macro to define accessors for different MuJoCo object types within mjModel.
// Each line calls X_ACCESSOR with the following arguments:
// 1.  NAME: The object type name in uppercase (e.g., ACTUATOR).
// 2.  Name: The object type name in CamelCase (e.g., Actuator).
// 3.  OBJTYPE: The corresponding mjOBJ_* enum value (e.g., mjOBJ_ACTUATOR).
// 4.  field: The name of the array field in mjModel (e.g., actuator).
// 5.  nfield: The name of the count field in mjModel (e.g., nu).
#define MJMODEL_ACCESSORS                                              \
  X_ACCESSOR( ACTUATOR, Actuator, mjOBJ_ACTUATOR, actuator, nu       ) \
  X_ACCESSOR( BODY,     Body,     mjOBJ_BODY,     body,     nbody    ) \
  X_ACCESSOR( CAMERA,   Camera,   mjOBJ_CAMERA,   cam,      ncam     ) \
  X_ACCESSOR( EQUALITY, Equality, mjOBJ_EQUALITY, eq,       neq      ) \
  X_ACCESSOR( EXCLUDE,  Exclude,  mjOBJ_EXCLUDE,  exclude,  nexclude ) \
  X_ACCESSOR( GEOM,     Geom,     mjOBJ_GEOM,     geom,     ngeom    ) \
  X_ACCESSOR( HFIELD,   Hfield,   mjOBJ_HFIELD,   hfield,   nhfield  ) \
  X_ACCESSOR( JOINT,    Joint,    mjOBJ_JOINT,    jnt,      njnt     ) \
  X_ACCESSOR( LIGHT,    Light,    mjOBJ_LIGHT,    light,    nlight   ) \
  X_ACCESSOR( MATERIAL, Material, mjOBJ_MATERIAL, mat,      nmat     ) \
  X_ACCESSOR( MESH,     Mesh,     mjOBJ_MESH,     mesh,     nmesh    ) \
  X_ACCESSOR( NUMERIC,  Numeric,  mjOBJ_NUMERIC,  numeric,  nnumeric ) \
  X_ACCESSOR( PAIR,     Pair,     mjOBJ_PAIR,     pair,     npair    ) \
  X_ACCESSOR( SENSOR,   Sensor,   mjOBJ_SENSOR,   sensor,   nsensor  ) \
  X_ACCESSOR( SITE,     Site,     mjOBJ_SITE,     site,     nsite    ) \
  X_ACCESSOR( SKIN,     Skin,     mjOBJ_SKIN,     skin,     nskin    ) \
  X_ACCESSOR( TENDON,   Tendon,   mjOBJ_TENDON,   tendon,   ntendon  ) \
  X_ACCESSOR( TEXTURE,  Texture,  mjOBJ_TEXTURE,  tex,      ntex     ) \
  X_ACCESSOR( TUPLE,    Tuple,    mjOBJ_TUPLE,    tuple,    ntuple   ) \
  X_ACCESSOR( KEYFRAME, Keyframe, mjOBJ_KEY,      key,      nkey     )

// Macro to define accessors for different MuJoCo object types within mjData.
// Each line calls X_ACCESSOR with the following arguments:
// 1.  NAME: The object type name in uppercase (e.g., ACTUATOR).
// 2.  Name: The object type name in CamelCase (e.g., Actuator).
// 3.  OBJTYPE: The corresponding mjOBJ_* enum value (e.g., mjOBJ_ACTUATOR).
// 4.  field: The name of the array field in mjData (e.g., actuator).
// 5.  nfield: The name of the count field in mjModel (e.g., nu).
#define MJDATA_ACCESSORS                                               \
  X_ACCESSOR( ACTUATOR, Actuator, mjOBJ_ACTUATOR, actuator, nu       ) \
  X_ACCESSOR( BODY,     Body,     mjOBJ_BODY,     body,     nbody    ) \
  X_ACCESSOR( CAMERA,   Camera,   mjOBJ_CAMERA,   cam,      ncam     ) \
  X_ACCESSOR( GEOM,     Geom,     mjOBJ_GEOM,     geom,     ngeom    ) \
  X_ACCESSOR( JOINT,    Joint,    mjOBJ_JOINT,    jnt,      njnt     ) \
  X_ACCESSOR( LIGHT,    Light,    mjOBJ_LIGHT,    light,    nlight   ) \
  X_ACCESSOR( SENSOR,   Sensor,   mjOBJ_SENSOR,   sensor,   nsensor  ) \
  X_ACCESSOR( SITE,     Site,     mjOBJ_SITE,     site,     nsite    ) \
  X_ACCESSOR( TENDON,   Tendon,   mjOBJ_TENDON,   tendon,   ntendon  )

// Raises an error if the given val is null or undefined.
// A macro is used so that the error contains the name of the variable.
// TODO(matijak): Remove this when we can handle strings using UNPACK_STRING?
#define CHECK_VAL(val)                                    \
  if (val.isNull()) {                                     \
    mju_error("Invalid argument: %s is null", #val);      \
  } else if (val.isUndefined()) {                         \
    mju_error("Invalid argument: %s is undefined", #val); \
  }

std::string KeyErrorMessage(const mjModel* model, int objtype, int count,
                            std::string_view name, std::string_view accessor_name);

std::string IndexErrorMessage(int index, int count,
                              std::string_view accessor_name);

using mjVisualGlobal = decltype(::mjVisual::global);
using mjVisualHeadlight = decltype(::mjVisual::headlight);
using mjVisualMap = decltype(::mjVisual::map);
using mjVisualQuality = decltype(::mjVisual::quality);
using mjVisualRgba = decltype(::mjVisual::rgba);
using mjVisualScale = decltype(::mjVisual::scale);

#undef MJ_M
#define MJ_M(n) model_->n
// The X macro expands to a member function within an MjModel...Accessor struct.
// This function returns an emscripten::val, typically a typed memory view,
// providing access to array data within the underlying mjModel. The size and
// offset of the memory view are determined by the arguments:
// - type: The C++ type of the array elements (e.g., mjtNum, int).
// - prefix: The prefix of the field name in mjModel (e.g., jnt_, geom_).
// - var: The name of the field being accessed (e.g., qposadr, size).
// - dim0: Used to determine special indexing logic for dynamically sized arrays
//         like joints (nq, nv), hfields, textures, numerics, and tuples.
// - dim1: The fixed dimension of the array if not dynamically sized. If "1",
//         a single element is returned. Otherwise, it's used as the stride
//         for the typed memory view.
#define X(type, prefix, var, dim0, dim1)                                                         \
  emscripten::val get_##var() const {                                                            \
    if constexpr (std::string_view(#dim0) == "nq") {                                             \
      int start = model_->jnt_qposadr[id_];                                                      \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq;            \
      return val(typed_memory_view(end - start, model_->prefix##var + start));                   \
    } else if constexpr (std::string_view(#dim0) == "nv") {                                      \
      int start = model_->jnt_dofadr[id_];                                                       \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv;             \
      return val(typed_memory_view(end - start, model_->prefix##var + start));                   \
    } else if constexpr (std::string_view(#dim0) == "nhfielddata") {                             \
      int start = model_->hfield_adr[id_];                                                       \
      int count = model_->hfield_nrow[id_] * model_->hfield_ncol[id_];                           \
      return val(typed_memory_view(count, model_->hfield_data + start));                         \
    } else if constexpr (std::string_view(#dim0) == "ntexdata") {                                \
      int start = model_->tex_adr[id_];                                                          \
      int count = model_->tex_height[id_] * model_->tex_width[id_] * model_->tex_nchannel[id_];  \
      return val(typed_memory_view(count, model_->tex_data + start));                            \
    } else if constexpr (std::string_view(#dim0) == "nnumericdata") {                            \
      int start = model_->numeric_adr[id_];                                                      \
      int count = model_->numeric_size[id_];                                                     \
      return val(typed_memory_view(count, model_->numeric_data + start));                        \
    } else if constexpr (std::string_view(#dim0) == "ntupledata") {                              \
      int start = model_->tuple_adr[id_];                                                        \
      int count = model_->tuple_size[id_];                                                       \
      return val(typed_memory_view(count, model_->prefix##var + start));                         \
    } else {                                                                                     \
      if constexpr (std::string_view(#dim1) == "1") {                                            \
        return val(model_->prefix##var[id_]);                                                    \
      } else {                                                                                   \
        return val(typed_memory_view(dim1, model_->prefix##var + id_ * dim1));                   \
      }                                                                                          \
    }                                                                                            \
  }                                                                                              \
  void set_##var(const emscripten::val& value) {                                                 \
    if constexpr (std::string_view(#dim0) == "nq") {                                             \
      int start = model_->jnt_qposadr[id_];                                                      \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq;            \
      val(typed_memory_view(end - start, model_->prefix##var + start))                           \
          .call<void>("set", value);                                                             \
    } else if constexpr (std::string_view(#dim0) == "nv") {                                      \
      int start = model_->jnt_dofadr[id_];                                                       \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv;             \
      val(typed_memory_view(end - start, model_->prefix##var + start))                           \
          .call<void>("set", value);                                                             \
    } else if constexpr (std::string_view(#dim0) == "nhfielddata") {                             \
      int start = model_->hfield_adr[id_];                                                       \
      int count = model_->hfield_nrow[id_] * model_->hfield_ncol[id_];                           \
      val(typed_memory_view(count, model_->hfield_data + start))                                 \
          .call<void>("set", value);                                                             \
    } else if constexpr (std::string_view(#dim0) == "ntexdata") {                                \
      int start = model_->tex_adr[id_];                                                          \
      int count = model_->tex_height[id_] * model_->tex_width[id_] * model_->tex_nchannel[id_];  \
      val(typed_memory_view(count, model_->tex_data + start))                                    \
          .call<void>("set", value);                                                             \
    } else if constexpr (std::string_view(#dim0) == "nnumericdata") {                            \
      int start = model_->numeric_adr[id_];                                                      \
      int count = model_->numeric_size[id_];                                                     \
      val(typed_memory_view(count, model_->numeric_data + start))                                \
          .call<void>("set", value);                                                             \
    } else if constexpr (std::string_view(#dim0) == "ntupledata") {                              \
      int start = model_->tuple_adr[id_];                                                        \
      int count = model_->tuple_size[id_];                                                       \
      val(typed_memory_view(count, model_->prefix##var + start))                                 \
          .call<void>("set", value);                                                             \
    } else {                                                                                     \
      if constexpr (std::string_view(#dim1) == "1") {                                            \
        model_->prefix##var[id_] = value.as<type>();                                             \
      } else {                                                                                   \
        val(typed_memory_view(dim1, model_->prefix##var + id_ * dim1))                           \
            .call<void>("set", value);                                                           \
      }                                                                                          \
    }                                                                                            \
  }

// Expands to a struct definition for each object type in MJMODEL_ACCESSORS.
// Each struct, named `MjModel{Name}Accessor`, provides:
// - A constructor taking an `mjModel*` and an integer `id`.
// - An `id()` method to get the object's index.
// - A `name()` method to get the object's name using `mj_id2name`.
// - Member functions generated by the `MJMODEL_##NAME` macro, which in turn
//   uses the `X` macro to define accessors for fields within `mjModel`.
#define X_ACCESSOR(NAME, Name, OBJTYPE, field, nfield)                           \
  struct MjModel##Name##Accessor {                                               \
    MjModel##Name##Accessor(mjModel* model, int id) : model_(model), id_(id) {}  \
                                                                                 \
    int id() const { return id_; }                                               \
    std::string name() const {                                                   \
      const char* name = mj_id2name(model_, OBJTYPE, id_);                       \
      return name ? name : "";                                                   \
    }                                                                            \
                                                                                 \
    MJMODEL_##NAME                                                               \
                                                                                 \
   private:                                                                      \
    mjModel* model_;                                                             \
    int id_;                                                                     \
  };
MJMODEL_ACCESSORS
#undef X_ACCESSOR

// Expands to a struct definition for each object type in MJDATA_ACCESSORS.
// Each struct, named `MjData{Name}Accessor`, provides:
// - A constructor taking an `mjData*`, an `mjModel*`, and an integer `id`.
// - An `id()` method to get the object's index.
// - A `name()` method to get the object's name using `mj_id2name`.
// - Member functions generated by the `MJDATA_##NAME` macro, which in turn
//   uses the `X` macro to define accessors for fields within `mjData`.
#undef MJ_M
#define MJ_M(n) model_->n
#undef X
#define X(type, prefix, var, dim0, dim1)                                               \
  emscripten::val get_##var() const {                                                  \
    if constexpr (std::string_view(#dim0) == "nq") {                                   \
      int start = model_->jnt_qposadr[id_];                                            \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq;  \
      return val(typed_memory_view(end - start, data_->prefix##var + start));          \
    } else if constexpr (std::string_view(#dim0) == "nv") {                            \
      int start = model_->jnt_dofadr[id_];                                             \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv;   \
      if constexpr (std::string_view(#dim1) == "1") {                                  \
        return val(typed_memory_view(end - start, data_->prefix##var + start));        \
      } else {                                                                         \
        return val(typed_memory_view(                                                  \
            (end - start) * dim1, data_->prefix##var + start * dim1));                 \
      }                                                                                \
    } else if constexpr (std::string_view(#dim0) == "nsensordata") {                   \
      int start = model_->sensor_adr[id_];                                             \
      int count = model_->sensor_dim[id_];                                             \
      return val(typed_memory_view(count, data_->sensordata + start));                 \
    } else {                                                                           \
      if constexpr (std::string_view(#dim1) == "1") {                                  \
        return val(data_->prefix##var[id_]);                                           \
      } else {                                                                         \
        return val(typed_memory_view(dim1, data_->prefix##var + id_ * dim1));          \
      }                                                                                \
    }                                                                                  \
  }                                                                                    \
  void set_##var(const emscripten::val& value) {                                       \
    if constexpr (std::string_view(#dim0) == "nq") {                                   \
      int start = model_->jnt_qposadr[id_];                                            \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq;  \
      val(typed_memory_view(end - start, data_->prefix##var + start))                  \
          .call<void>("set", value);                                                   \
    } else if constexpr (std::string_view(#dim0) == "nv") {                            \
      int start = model_->jnt_dofadr[id_];                                             \
      int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv;   \
      if constexpr (std::string_view(#dim1) == "1") {                                  \
        val(typed_memory_view(end - start, data_->prefix##var + start))                \
            .call<void>("set", value);                                                 \
      } else {                                                                         \
        val(typed_memory_view((end - start) * dim1,                                    \
                                          data_->prefix##var + start * dim1))          \
            .call<void>("set", value);                                                 \
      }                                                                                \
    } else if constexpr (std::string_view(#dim0) == "nsensordata") {                   \
      int start = model_->sensor_adr[id_];                                             \
      int count = model_->sensor_dim[id_];                                             \
      val(typed_memory_view(count, data_->sensordata + start))                         \
          .call<void>("set", value);                                                   \
    } else {                                                                           \
      if constexpr (std::string_view(#dim1) == "1") {                                  \
        data_->prefix##var[id_] = value.as<type>();                                    \
      } else {                                                                         \
        val(typed_memory_view(dim1, data_->prefix##var + id_ * dim1))                  \
            .call<void>("set", value);                                                 \
      }                                                                                \
    }                                                                                  \
  }

#define X_ACCESSOR(NAME, Name, OBJTYPE, field, nfield)                                                     \
  struct MjData##Name##Accessor {                                                                          \
    MjData##Name##Accessor(mjData* data, mjModel* model, int id) : data_(data), model_(model), id_(id) {}  \
                                                                                                           \
    int id() const { return id_; }                                                                         \
    std::string name() const {                                                                             \
      const char* name = mj_id2name(model_, OBJTYPE, id_);                                                 \
      return name ? name : "";                                                                             \
    }                                                                                                      \
                                                                                                           \
    MJDATA_##NAME                                                                                          \
                                                                                                           \
   private:                                                                                                \
    mjData* data_;                                                                                         \
    mjModel* model_;                                                                                       \
    int id_;                                                                                               \
  };
MJDATA_ACCESSORS
#undef X_ACCESSOR

#undef X
#undef MJ_M

struct MjContact {
  ~MjContact();
  MjContact();
  explicit MjContact(mjContact *ptr);
  MjContact(const MjContact &);
  MjContact &operator=(const MjContact &);
  std::unique_ptr<MjContact> copy();
  mjContact* get() const;
  void set(mjContact* ptr);
  mjtNum dist() const {
    return ptr_->dist;
  }
  void set_dist(mjtNum value) {
    ptr_->dist = value;
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val frame() const {
    return emscripten::val(emscripten::typed_memory_view(9, ptr_->frame));
  }
  mjtNum includemargin() const {
    return ptr_->includemargin;
  }
  void set_includemargin(mjtNum value) {
    ptr_->includemargin = value;
  }
  emscripten::val friction() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->friction));
  }
  emscripten::val solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
  }
  emscripten::val solreffriction() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solreffriction));
  }
  emscripten::val solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
  }
  mjtNum adhesion() const {
    return ptr_->adhesion;
  }
  void set_adhesion(mjtNum value) {
    ptr_->adhesion = value;
  }
  mjtNum mu() const {
    return ptr_->mu;
  }
  void set_mu(mjtNum value) {
    ptr_->mu = value;
  }
  emscripten::val H() const {
    return emscripten::val(emscripten::typed_memory_view(36, ptr_->H));
  }
  int dim() const {
    return ptr_->dim;
  }
  void set_dim(int value) {
    ptr_->dim = value;
  }
  int geom1() const {
    return ptr_->geom1;
  }
  void set_geom1(int value) {
    ptr_->geom1 = value;
  }
  int geom2() const {
    return ptr_->geom2;
  }
  void set_geom2(int value) {
    ptr_->geom2 = value;
  }
  emscripten::val geom() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->geom));
  }
  emscripten::val flex() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->flex));
  }
  emscripten::val elem() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->elem));
  }
  emscripten::val vert() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->vert));
  }
  int exclude() const {
    return ptr_->exclude;
  }
  void set_exclude(int value) {
    ptr_->exclude = value;
  }
  int efc_address() const {
    return ptr_->efc_address;
  }
  void set_efc_address(int value) {
    ptr_->efc_address = value;
  }

 private:
  mjContact* ptr_;
  bool owned_ = false;
};

struct MjLROpt {
  ~MjLROpt();
  MjLROpt();
  explicit MjLROpt(mjLROpt *ptr);
  MjLROpt(const MjLROpt &);
  MjLROpt &operator=(const MjLROpt &);
  std::unique_ptr<MjLROpt> copy();
  mjLROpt* get() const;
  void set(mjLROpt* ptr);
  int mode() const {
    return ptr_->mode;
  }
  void set_mode(int value) {
    ptr_->mode = value;
  }
  int useexisting() const {
    return ptr_->useexisting;
  }
  void set_useexisting(int value) {
    ptr_->useexisting = value;
  }
  int uselimit() const {
    return ptr_->uselimit;
  }
  void set_uselimit(int value) {
    ptr_->uselimit = value;
  }
  mjtNum accel() const {
    return ptr_->accel;
  }
  void set_accel(mjtNum value) {
    ptr_->accel = value;
  }
  mjtNum maxforce() const {
    return ptr_->maxforce;
  }
  void set_maxforce(mjtNum value) {
    ptr_->maxforce = value;
  }
  mjtNum timeconst() const {
    return ptr_->timeconst;
  }
  void set_timeconst(mjtNum value) {
    ptr_->timeconst = value;
  }
  mjtNum timestep() const {
    return ptr_->timestep;
  }
  void set_timestep(mjtNum value) {
    ptr_->timestep = value;
  }
  mjtNum inttotal() const {
    return ptr_->inttotal;
  }
  void set_inttotal(mjtNum value) {
    ptr_->inttotal = value;
  }
  mjtNum interval() const {
    return ptr_->interval;
  }
  void set_interval(mjtNum value) {
    ptr_->interval = value;
  }
  mjtNum tolrange() const {
    return ptr_->tolrange;
  }
  void set_tolrange(mjtNum value) {
    ptr_->tolrange = value;
  }

 private:
  mjLROpt* ptr_;
  bool owned_ = false;
};

struct MjLogConfig {
  ~MjLogConfig();
  MjLogConfig();
  explicit MjLogConfig(mjLogConfig *ptr);
  MjLogConfig(const MjLogConfig &);
  MjLogConfig &operator=(const MjLogConfig &);
  std::unique_ptr<MjLogConfig> copy();
  mjLogConfig* get() const;
  void set(mjLogConfig* ptr);
  mjtBool logto_console() const {
    return ptr_->logto_console;
  }
  void set_logto_console(mjtBool value) {
    ptr_->logto_console = value;
  }
  mjtBool logto_file() const {
    return ptr_->logto_file;
  }
  void set_logto_file(mjtBool value) {
    ptr_->logto_file = value;
  }
  emscripten::val logfile() const {
    return emscripten::val(emscripten::typed_memory_view(1024, ptr_->logfile));
  }
  int topics() const {
    return ptr_->topics;
  }
  void set_topics(int value) {
    ptr_->topics = value;
  }

 private:
  mjLogConfig* ptr_;
  bool owned_ = false;
};

struct MjLogMessage {
  ~MjLogMessage();
  MjLogMessage();
  explicit MjLogMessage(mjLogMessage *ptr);
  mjLogMessage* get() const;
  void set(mjLogMessage* ptr);
  int level() const {
    return ptr_->level;
  }
  void set_level(int value) {
    ptr_->level = value;
  }
  int topic() const {
    return ptr_->topic;
  }
  void set_topic(int value) {
    ptr_->topic = value;
  }
  emscripten::val subject() const {
    return emscripten::val(emscripten::typed_memory_view(1024, ptr_->subject));
  }
  std::string body() const {
    return ptr_->body ? std::string(ptr_->body) : "";
  }
  std::string func() const {
    return ptr_->func ? std::string(ptr_->func) : "";
  }
  std::string file() const {
    return ptr_->file ? std::string(ptr_->file) : "";
  }
  int line() const {
    return ptr_->line;
  }
  void set_line(int value) {
    ptr_->line = value;
  }
  mjtBool timestamp() const {
    return ptr_->timestamp;
  }
  void set_timestamp(mjtBool value) {
    ptr_->timestamp = value;
  }

 private:
  mjLogMessage* ptr_;
  bool owned_ = false;
};

struct MjOption {
  ~MjOption();
  MjOption();
  explicit MjOption(mjOption *ptr);
  MjOption(const MjOption &);
  MjOption &operator=(const MjOption &);
  std::unique_ptr<MjOption> copy();
  mjOption* get() const;
  void set(mjOption* ptr);
  mjtNum timestep() const {
    return ptr_->timestep;
  }
  void set_timestep(mjtNum value) {
    ptr_->timestep = value;
  }
  mjtNum impratio() const {
    return ptr_->impratio;
  }
  void set_impratio(mjtNum value) {
    ptr_->impratio = value;
  }
  mjtNum tolerance() const {
    return ptr_->tolerance;
  }
  void set_tolerance(mjtNum value) {
    ptr_->tolerance = value;
  }
  mjtNum ls_tolerance() const {
    return ptr_->ls_tolerance;
  }
  void set_ls_tolerance(mjtNum value) {
    ptr_->ls_tolerance = value;
  }
  mjtNum noslip_tolerance() const {
    return ptr_->noslip_tolerance;
  }
  void set_noslip_tolerance(mjtNum value) {
    ptr_->noslip_tolerance = value;
  }
  mjtNum ccd_tolerance() const {
    return ptr_->ccd_tolerance;
  }
  void set_ccd_tolerance(mjtNum value) {
    ptr_->ccd_tolerance = value;
  }
  mjtNum sleep_tolerance() const {
    return ptr_->sleep_tolerance;
  }
  void set_sleep_tolerance(mjtNum value) {
    ptr_->sleep_tolerance = value;
  }
  emscripten::val gravity() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->gravity));
  }
  emscripten::val wind() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->wind));
  }
  emscripten::val magnetic() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->magnetic));
  }
  mjtNum density() const {
    return ptr_->density;
  }
  void set_density(mjtNum value) {
    ptr_->density = value;
  }
  mjtNum viscosity() const {
    return ptr_->viscosity;
  }
  void set_viscosity(mjtNum value) {
    ptr_->viscosity = value;
  }
  mjtNum o_margin() const {
    return ptr_->o_margin;
  }
  void set_o_margin(mjtNum value) {
    ptr_->o_margin = value;
  }
  emscripten::val o_solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->o_solref));
  }
  emscripten::val o_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->o_solimp));
  }
  emscripten::val o_friction() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->o_friction));
  }
  int integrator() const {
    return ptr_->integrator;
  }
  void set_integrator(int value) {
    ptr_->integrator = value;
  }
  int cone() const {
    return ptr_->cone;
  }
  void set_cone(int value) {
    ptr_->cone = value;
  }
  int jacobian() const {
    return ptr_->jacobian;
  }
  void set_jacobian(int value) {
    ptr_->jacobian = value;
  }
  int solver() const {
    return ptr_->solver;
  }
  void set_solver(int value) {
    ptr_->solver = value;
  }
  int iterations() const {
    return ptr_->iterations;
  }
  void set_iterations(int value) {
    ptr_->iterations = value;
  }
  int ls_iterations() const {
    return ptr_->ls_iterations;
  }
  void set_ls_iterations(int value) {
    ptr_->ls_iterations = value;
  }
  int noslip_iterations() const {
    return ptr_->noslip_iterations;
  }
  void set_noslip_iterations(int value) {
    ptr_->noslip_iterations = value;
  }
  int ccd_iterations() const {
    return ptr_->ccd_iterations;
  }
  void set_ccd_iterations(int value) {
    ptr_->ccd_iterations = value;
  }
  int disableflags() const {
    return ptr_->disableflags;
  }
  void set_disableflags(int value) {
    ptr_->disableflags = value;
  }
  int enableflags() const {
    return ptr_->enableflags;
  }
  void set_enableflags(int value) {
    ptr_->enableflags = value;
  }
  int disableactuator() const {
    return ptr_->disableactuator;
  }
  void set_disableactuator(int value) {
    ptr_->disableactuator = value;
  }
  int sdf_initpoints() const {
    return ptr_->sdf_initpoints;
  }
  void set_sdf_initpoints(int value) {
    ptr_->sdf_initpoints = value;
  }
  int sdf_iterations() const {
    return ptr_->sdf_iterations;
  }
  void set_sdf_iterations(int value) {
    ptr_->sdf_iterations = value;
  }

 private:
  mjOption* ptr_;
  bool owned_ = false;
};

struct MjPreContact {
  ~MjPreContact();
  MjPreContact();
  explicit MjPreContact(mjPreContact *ptr);
  MjPreContact(const MjPreContact &);
  MjPreContact &operator=(const MjPreContact &);
  std::unique_ptr<MjPreContact> copy();
  mjPreContact* get() const;
  void set(mjPreContact* ptr);
  mjtNum dist() const {
    return ptr_->dist;
  }
  void set_dist(mjtNum value) {
    ptr_->dist = value;
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val normal() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->normal));
  }
  emscripten::val tangent() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->tangent));
  }

 private:
  mjPreContact* ptr_;
  bool owned_ = false;
};

struct MjSolverStat {
  ~MjSolverStat();
  MjSolverStat();
  explicit MjSolverStat(mjSolverStat *ptr);
  MjSolverStat(const MjSolverStat &);
  MjSolverStat &operator=(const MjSolverStat &);
  std::unique_ptr<MjSolverStat> copy();
  mjSolverStat* get() const;
  void set(mjSolverStat* ptr);
  mjtNum improvement() const {
    return ptr_->improvement;
  }
  void set_improvement(mjtNum value) {
    ptr_->improvement = value;
  }
  mjtNum gradient() const {
    return ptr_->gradient;
  }
  void set_gradient(mjtNum value) {
    ptr_->gradient = value;
  }
  mjtNum lineslope() const {
    return ptr_->lineslope;
  }
  void set_lineslope(mjtNum value) {
    ptr_->lineslope = value;
  }
  int nactive() const {
    return ptr_->nactive;
  }
  void set_nactive(int value) {
    ptr_->nactive = value;
  }
  int nchange() const {
    return ptr_->nchange;
  }
  void set_nchange(int value) {
    ptr_->nchange = value;
  }
  int neval() const {
    return ptr_->neval;
  }
  void set_neval(int value) {
    ptr_->neval = value;
  }
  int nupdate() const {
    return ptr_->nupdate;
  }
  void set_nupdate(int value) {
    ptr_->nupdate = value;
  }

 private:
  mjSolverStat* ptr_;
  bool owned_ = false;
};

struct MjStatistic {
  ~MjStatistic();
  MjStatistic();
  explicit MjStatistic(mjStatistic *ptr);
  MjStatistic(const MjStatistic &);
  MjStatistic &operator=(const MjStatistic &);
  std::unique_ptr<MjStatistic> copy();
  mjStatistic* get() const;
  void set(mjStatistic* ptr);
  mjtNum meaninertia() const {
    return ptr_->meaninertia;
  }
  void set_meaninertia(mjtNum value) {
    ptr_->meaninertia = value;
  }
  mjtNum meanmass() const {
    return ptr_->meanmass;
  }
  void set_meanmass(mjtNum value) {
    ptr_->meanmass = value;
  }
  mjtNum meansize() const {
    return ptr_->meansize;
  }
  void set_meansize(mjtNum value) {
    ptr_->meansize = value;
  }
  mjtNum extent() const {
    return ptr_->extent;
  }
  void set_extent(mjtNum value) {
    ptr_->extent = value;
  }
  emscripten::val center() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->center));
  }

 private:
  mjStatistic* ptr_;
  bool owned_ = false;
};

struct MjTimerStat {
  ~MjTimerStat();
  MjTimerStat();
  explicit MjTimerStat(mjTimerStat *ptr);
  MjTimerStat(const MjTimerStat &);
  MjTimerStat &operator=(const MjTimerStat &);
  std::unique_ptr<MjTimerStat> copy();
  mjTimerStat* get() const;
  void set(mjTimerStat* ptr);
  mjtNum duration() const {
    return ptr_->duration;
  }
  void set_duration(mjtNum value) {
    ptr_->duration = value;
  }
  int number() const {
    return ptr_->number;
  }
  void set_number(int value) {
    ptr_->number = value;
  }

 private:
  mjTimerStat* ptr_;
  bool owned_ = false;
};

struct MjVisualGlobal {
  ~MjVisualGlobal();
  MjVisualGlobal();
  explicit MjVisualGlobal(mjVisualGlobal *ptr);
  MjVisualGlobal(const MjVisualGlobal &);
  MjVisualGlobal &operator=(const MjVisualGlobal &);
  std::unique_ptr<MjVisualGlobal> copy();
  mjVisualGlobal* get() const;
  void set(mjVisualGlobal* ptr);
  int cameraid() const {
    return ptr_->cameraid;
  }
  void set_cameraid(int value) {
    ptr_->cameraid = value;
  }
  int orthographic() const {
    return ptr_->orthographic;
  }
  void set_orthographic(int value) {
    ptr_->orthographic = value;
  }
  float fovy() const {
    return ptr_->fovy;
  }
  void set_fovy(float value) {
    ptr_->fovy = value;
  }
  float ipd() const {
    return ptr_->ipd;
  }
  void set_ipd(float value) {
    ptr_->ipd = value;
  }
  float azimuth() const {
    return ptr_->azimuth;
  }
  void set_azimuth(float value) {
    ptr_->azimuth = value;
  }
  float elevation() const {
    return ptr_->elevation;
  }
  void set_elevation(float value) {
    ptr_->elevation = value;
  }
  float linewidth() const {
    return ptr_->linewidth;
  }
  void set_linewidth(float value) {
    ptr_->linewidth = value;
  }
  float glow() const {
    return ptr_->glow;
  }
  void set_glow(float value) {
    ptr_->glow = value;
  }
  float realtime() const {
    return ptr_->realtime;
  }
  void set_realtime(float value) {
    ptr_->realtime = value;
  }
  int offwidth() const {
    return ptr_->offwidth;
  }
  void set_offwidth(int value) {
    ptr_->offwidth = value;
  }
  int offheight() const {
    return ptr_->offheight;
  }
  void set_offheight(int value) {
    ptr_->offheight = value;
  }
  int ellipsoidinertia() const {
    return ptr_->ellipsoidinertia;
  }
  void set_ellipsoidinertia(int value) {
    ptr_->ellipsoidinertia = value;
  }
  int bvactive() const {
    return ptr_->bvactive;
  }
  void set_bvactive(int value) {
    ptr_->bvactive = value;
  }

 private:
  mjVisualGlobal* ptr_;
  bool owned_ = false;
};

struct MjVisualHeadlight {
  ~MjVisualHeadlight();
  MjVisualHeadlight();
  explicit MjVisualHeadlight(mjVisualHeadlight *ptr);
  MjVisualHeadlight(const MjVisualHeadlight &);
  MjVisualHeadlight &operator=(const MjVisualHeadlight &);
  std::unique_ptr<MjVisualHeadlight> copy();
  mjVisualHeadlight* get() const;
  void set(mjVisualHeadlight* ptr);
  emscripten::val ambient() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
  }
  emscripten::val diffuse() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
  }
  emscripten::val specular() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
  }
  int active() const {
    return ptr_->active;
  }
  void set_active(int value) {
    ptr_->active = value;
  }

 private:
  mjVisualHeadlight* ptr_;
  bool owned_ = false;
};

struct MjVisualMap {
  ~MjVisualMap();
  MjVisualMap();
  explicit MjVisualMap(mjVisualMap *ptr);
  MjVisualMap(const MjVisualMap &);
  MjVisualMap &operator=(const MjVisualMap &);
  std::unique_ptr<MjVisualMap> copy();
  mjVisualMap* get() const;
  void set(mjVisualMap* ptr);
  float stiffness() const {
    return ptr_->stiffness;
  }
  void set_stiffness(float value) {
    ptr_->stiffness = value;
  }
  float stiffnessrot() const {
    return ptr_->stiffnessrot;
  }
  void set_stiffnessrot(float value) {
    ptr_->stiffnessrot = value;
  }
  float force() const {
    return ptr_->force;
  }
  void set_force(float value) {
    ptr_->force = value;
  }
  float torque() const {
    return ptr_->torque;
  }
  void set_torque(float value) {
    ptr_->torque = value;
  }
  float alpha() const {
    return ptr_->alpha;
  }
  void set_alpha(float value) {
    ptr_->alpha = value;
  }
  float fogstart() const {
    return ptr_->fogstart;
  }
  void set_fogstart(float value) {
    ptr_->fogstart = value;
  }
  float fogend() const {
    return ptr_->fogend;
  }
  void set_fogend(float value) {
    ptr_->fogend = value;
  }
  float znear() const {
    return ptr_->znear;
  }
  void set_znear(float value) {
    ptr_->znear = value;
  }
  float zfar() const {
    return ptr_->zfar;
  }
  void set_zfar(float value) {
    ptr_->zfar = value;
  }
  float haze() const {
    return ptr_->haze;
  }
  void set_haze(float value) {
    ptr_->haze = value;
  }
  float shadowclip() const {
    return ptr_->shadowclip;
  }
  void set_shadowclip(float value) {
    ptr_->shadowclip = value;
  }
  float shadowscale() const {
    return ptr_->shadowscale;
  }
  void set_shadowscale(float value) {
    ptr_->shadowscale = value;
  }
  float actuatortendon() const {
    return ptr_->actuatortendon;
  }
  void set_actuatortendon(float value) {
    ptr_->actuatortendon = value;
  }

 private:
  mjVisualMap* ptr_;
  bool owned_ = false;
};

struct MjVisualQuality {
  ~MjVisualQuality();
  MjVisualQuality();
  explicit MjVisualQuality(mjVisualQuality *ptr);
  MjVisualQuality(const MjVisualQuality &);
  MjVisualQuality &operator=(const MjVisualQuality &);
  std::unique_ptr<MjVisualQuality> copy();
  mjVisualQuality* get() const;
  void set(mjVisualQuality* ptr);
  int shadowsize() const {
    return ptr_->shadowsize;
  }
  void set_shadowsize(int value) {
    ptr_->shadowsize = value;
  }
  int offsamples() const {
    return ptr_->offsamples;
  }
  void set_offsamples(int value) {
    ptr_->offsamples = value;
  }
  int numslices() const {
    return ptr_->numslices;
  }
  void set_numslices(int value) {
    ptr_->numslices = value;
  }
  int numstacks() const {
    return ptr_->numstacks;
  }
  void set_numstacks(int value) {
    ptr_->numstacks = value;
  }
  int numquads() const {
    return ptr_->numquads;
  }
  void set_numquads(int value) {
    ptr_->numquads = value;
  }

 private:
  mjVisualQuality* ptr_;
  bool owned_ = false;
};

struct MjVisualRgba {
  ~MjVisualRgba();
  MjVisualRgba();
  explicit MjVisualRgba(mjVisualRgba *ptr);
  MjVisualRgba(const MjVisualRgba &);
  MjVisualRgba &operator=(const MjVisualRgba &);
  std::unique_ptr<MjVisualRgba> copy();
  mjVisualRgba* get() const;
  void set(mjVisualRgba* ptr);
  emscripten::val fog() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->fog));
  }
  emscripten::val haze() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->haze));
  }
  emscripten::val force() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->force));
  }
  emscripten::val inertia() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->inertia));
  }
  emscripten::val joint() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->joint));
  }
  emscripten::val actuator() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuator));
  }
  emscripten::val actuatornegative() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuatornegative));
  }
  emscripten::val actuatorpositive() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuatorpositive));
  }
  emscripten::val com() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->com));
  }
  emscripten::val camera() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->camera));
  }
  emscripten::val light() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->light));
  }
  emscripten::val selectpoint() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->selectpoint));
  }
  emscripten::val connect() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->connect));
  }
  emscripten::val contactpoint() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactpoint));
  }
  emscripten::val contactforce() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactforce));
  }
  emscripten::val contactfriction() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactfriction));
  }
  emscripten::val contacttorque() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->contacttorque));
  }
  emscripten::val contactgap() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactgap));
  }
  emscripten::val rangefinder() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rangefinder));
  }
  emscripten::val constraint() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->constraint));
  }
  emscripten::val slidercrank() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->slidercrank));
  }
  emscripten::val crankbroken() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->crankbroken));
  }
  emscripten::val frustum() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->frustum));
  }
  emscripten::val bv() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->bv));
  }
  emscripten::val bvactive() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->bvactive));
  }

 private:
  mjVisualRgba* ptr_;
  bool owned_ = false;
};

struct MjVisualScale {
  ~MjVisualScale();
  MjVisualScale();
  explicit MjVisualScale(mjVisualScale *ptr);
  MjVisualScale(const MjVisualScale &);
  MjVisualScale &operator=(const MjVisualScale &);
  std::unique_ptr<MjVisualScale> copy();
  mjVisualScale* get() const;
  void set(mjVisualScale* ptr);
  float forcewidth() const {
    return ptr_->forcewidth;
  }
  void set_forcewidth(float value) {
    ptr_->forcewidth = value;
  }
  float contactwidth() const {
    return ptr_->contactwidth;
  }
  void set_contactwidth(float value) {
    ptr_->contactwidth = value;
  }
  float contactheight() const {
    return ptr_->contactheight;
  }
  void set_contactheight(float value) {
    ptr_->contactheight = value;
  }
  float connect() const {
    return ptr_->connect;
  }
  void set_connect(float value) {
    ptr_->connect = value;
  }
  float com() const {
    return ptr_->com;
  }
  void set_com(float value) {
    ptr_->com = value;
  }
  float camera() const {
    return ptr_->camera;
  }
  void set_camera(float value) {
    ptr_->camera = value;
  }
  float light() const {
    return ptr_->light;
  }
  void set_light(float value) {
    ptr_->light = value;
  }
  float selectpoint() const {
    return ptr_->selectpoint;
  }
  void set_selectpoint(float value) {
    ptr_->selectpoint = value;
  }
  float jointlength() const {
    return ptr_->jointlength;
  }
  void set_jointlength(float value) {
    ptr_->jointlength = value;
  }
  float jointwidth() const {
    return ptr_->jointwidth;
  }
  void set_jointwidth(float value) {
    ptr_->jointwidth = value;
  }
  float actuatorlength() const {
    return ptr_->actuatorlength;
  }
  void set_actuatorlength(float value) {
    ptr_->actuatorlength = value;
  }
  float actuatorwidth() const {
    return ptr_->actuatorwidth;
  }
  void set_actuatorwidth(float value) {
    ptr_->actuatorwidth = value;
  }
  float framelength() const {
    return ptr_->framelength;
  }
  void set_framelength(float value) {
    ptr_->framelength = value;
  }
  float framewidth() const {
    return ptr_->framewidth;
  }
  void set_framewidth(float value) {
    ptr_->framewidth = value;
  }
  float constraint() const {
    return ptr_->constraint;
  }
  void set_constraint(float value) {
    ptr_->constraint = value;
  }
  float slidercrank() const {
    return ptr_->slidercrank;
  }
  void set_slidercrank(float value) {
    ptr_->slidercrank = value;
  }
  float frustum() const {
    return ptr_->frustum;
  }
  void set_frustum(float value) {
    ptr_->frustum = value;
  }

 private:
  mjVisualScale* ptr_;
  bool owned_ = false;
};

struct MjWarningStat {
  ~MjWarningStat();
  MjWarningStat();
  explicit MjWarningStat(mjWarningStat *ptr);
  MjWarningStat(const MjWarningStat &);
  MjWarningStat &operator=(const MjWarningStat &);
  std::unique_ptr<MjWarningStat> copy();
  mjWarningStat* get() const;
  void set(mjWarningStat* ptr);
  int lastinfo() const {
    return ptr_->lastinfo;
  }
  void set_lastinfo(int value) {
    ptr_->lastinfo = value;
  }
  int number() const {
    return ptr_->number;
  }
  void set_number(int value) {
    ptr_->number = value;
  }

 private:
  mjWarningStat* ptr_;
  bool owned_ = false;
};

struct MjsAuthored {
  explicit MjsAuthored(mjsAuthored *ptr);
  mjsAuthored* get() const;
  void set(mjsAuthored* ptr);
  uint64_t option() const {
    return ptr_->option;
  }
  void set_option(uint64_t value) {
    ptr_->option = value;
  }
  int disableflags() const {
    return ptr_->disableflags;
  }
  void set_disableflags(int value) {
    ptr_->disableflags = value;
  }
  int enableflags() const {
    return ptr_->enableflags;
  }
  void set_enableflags(int value) {
    ptr_->enableflags = value;
  }
  int disableactuator() const {
    return ptr_->disableactuator;
  }
  void set_disableactuator(int value) {
    ptr_->disableactuator = value;
  }
  uint64_t visual_global() const {
    return ptr_->visual_global;
  }
  void set_visual_global(uint64_t value) {
    ptr_->visual_global = value;
  }
  uint64_t visual_quality() const {
    return ptr_->visual_quality;
  }
  void set_visual_quality(uint64_t value) {
    ptr_->visual_quality = value;
  }
  uint64_t visual_headlight() const {
    return ptr_->visual_headlight;
  }
  void set_visual_headlight(uint64_t value) {
    ptr_->visual_headlight = value;
  }
  uint64_t visual_map() const {
    return ptr_->visual_map;
  }
  void set_visual_map(uint64_t value) {
    ptr_->visual_map = value;
  }
  uint64_t visual_scale() const {
    return ptr_->visual_scale;
  }
  void set_visual_scale(uint64_t value) {
    ptr_->visual_scale = value;
  }
  uint64_t visual_rgba() const {
    return ptr_->visual_rgba;
  }
  void set_visual_rgba(uint64_t value) {
    ptr_->visual_rgba = value;
  }

 private:
  mjsAuthored* ptr_;
};

struct MjsElement {
  explicit MjsElement(mjsElement *ptr);
  mjsElement* get() const;
  void set(mjsElement* ptr);
  mjtObj elemtype() const {
    return ptr_->elemtype;
  }
  void set_elemtype(mjtObj value) {
    ptr_->elemtype = value;
  }
  uint64_t signature() const {
    return ptr_->signature;
  }
  void set_signature(uint64_t value) {
    ptr_->signature = value;
  }

 private:
  mjsElement* ptr_;
};

struct MjsOrientation {
  explicit MjsOrientation(mjsOrientation *ptr);
  mjsOrientation* get() const;
  void set(mjsOrientation* ptr);
  mjtOrientation type() const {
    return ptr_->type;
  }
  void set_type(mjtOrientation value) {
    ptr_->type = value;
  }
  emscripten::val axisangle() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->axisangle));
  }
  emscripten::val xyaxes() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->xyaxes));
  }
  emscripten::val zaxis() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->zaxis));
  }
  emscripten::val euler() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->euler));
  }

 private:
  mjsOrientation* ptr_;
};

struct MjvCamera {
  ~MjvCamera();
  MjvCamera();
  explicit MjvCamera(mjvCamera *ptr);
  MjvCamera(const MjvCamera &);
  MjvCamera &operator=(const MjvCamera &);
  std::unique_ptr<MjvCamera> copy();
  mjvCamera* get() const;
  void set(mjvCamera* ptr);
  int type() const {
    return ptr_->type;
  }
  void set_type(int value) {
    ptr_->type = value;
  }
  int fixedcamid() const {
    return ptr_->fixedcamid;
  }
  void set_fixedcamid(int value) {
    ptr_->fixedcamid = value;
  }
  int trackbodyid() const {
    return ptr_->trackbodyid;
  }
  void set_trackbodyid(int value) {
    ptr_->trackbodyid = value;
  }
  emscripten::val lookat() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->lookat));
  }
  mjtNum distance() const {
    return ptr_->distance;
  }
  void set_distance(mjtNum value) {
    ptr_->distance = value;
  }
  mjtNum azimuth() const {
    return ptr_->azimuth;
  }
  void set_azimuth(mjtNum value) {
    ptr_->azimuth = value;
  }
  mjtNum elevation() const {
    return ptr_->elevation;
  }
  void set_elevation(mjtNum value) {
    ptr_->elevation = value;
  }
  int orthographic() const {
    return ptr_->orthographic;
  }
  void set_orthographic(int value) {
    ptr_->orthographic = value;
  }

 private:
  mjvCamera* ptr_;
  bool owned_ = false;
};

struct MjvFigure {
  ~MjvFigure();
  MjvFigure();
  explicit MjvFigure(mjvFigure *ptr);
  MjvFigure(const MjvFigure &);
  MjvFigure &operator=(const MjvFigure &);
  std::unique_ptr<MjvFigure> copy();
  mjvFigure* get() const;
  void set(mjvFigure* ptr);
  int flg_legend() const {
    return ptr_->flg_legend;
  }
  void set_flg_legend(int value) {
    ptr_->flg_legend = value;
  }
  emscripten::val flg_ticklabel() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->flg_ticklabel));
  }
  int flg_extend() const {
    return ptr_->flg_extend;
  }
  void set_flg_extend(int value) {
    ptr_->flg_extend = value;
  }
  int flg_barplot() const {
    return ptr_->flg_barplot;
  }
  void set_flg_barplot(int value) {
    ptr_->flg_barplot = value;
  }
  int flg_selection() const {
    return ptr_->flg_selection;
  }
  void set_flg_selection(int value) {
    ptr_->flg_selection = value;
  }
  int flg_symmetric() const {
    return ptr_->flg_symmetric;
  }
  void set_flg_symmetric(int value) {
    ptr_->flg_symmetric = value;
  }
  float linewidth() const {
    return ptr_->linewidth;
  }
  void set_linewidth(float value) {
    ptr_->linewidth = value;
  }
  float gridwidth() const {
    return ptr_->gridwidth;
  }
  void set_gridwidth(float value) {
    ptr_->gridwidth = value;
  }
  emscripten::val gridsize() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->gridsize));
  }
  emscripten::val gridrgb() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->gridrgb));
  }
  emscripten::val figurergba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->figurergba));
  }
  emscripten::val panergba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->panergba));
  }
  emscripten::val legendrgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->legendrgba));
  }
  emscripten::val textrgb() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->textrgb));
  }
  emscripten::val linergb() const {
    return emscripten::val(emscripten::typed_memory_view(300, reinterpret_cast<float*>(ptr_->linergb)));
  }
  emscripten::val range() const {
    return emscripten::val(emscripten::typed_memory_view(4, reinterpret_cast<float*>(ptr_->range)));
  }
  emscripten::val xformat() const {
    return emscripten::val(emscripten::typed_memory_view(20, ptr_->xformat));
  }
  emscripten::val yformat() const {
    return emscripten::val(emscripten::typed_memory_view(20, ptr_->yformat));
  }
  emscripten::val minwidth() const {
    return emscripten::val(emscripten::typed_memory_view(20, ptr_->minwidth));
  }
  emscripten::val title() const {
    return emscripten::val(emscripten::typed_memory_view(1000, ptr_->title));
  }
  emscripten::val xlabel() const {
    return emscripten::val(emscripten::typed_memory_view(100, ptr_->xlabel));
  }
  emscripten::val linename() const {
    return emscripten::val(emscripten::typed_memory_view(10000, reinterpret_cast<char*>(ptr_->linename)));
  }
  int legendoffset() const {
    return ptr_->legendoffset;
  }
  void set_legendoffset(int value) {
    ptr_->legendoffset = value;
  }
  int subplot() const {
    return ptr_->subplot;
  }
  void set_subplot(int value) {
    ptr_->subplot = value;
  }
  emscripten::val highlight() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->highlight));
  }
  int highlightid() const {
    return ptr_->highlightid;
  }
  void set_highlightid(int value) {
    ptr_->highlightid = value;
  }
  float selection() const {
    return ptr_->selection;
  }
  void set_selection(float value) {
    ptr_->selection = value;
  }
  emscripten::val linepnt() const {
    return emscripten::val(emscripten::typed_memory_view(100, ptr_->linepnt));
  }
  emscripten::val linedata() const {
    return emscripten::val(emscripten::typed_memory_view(200200, reinterpret_cast<float*>(ptr_->linedata)));
  }
  emscripten::val xaxispixel() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->xaxispixel));
  }
  emscripten::val yaxispixel() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->yaxispixel));
  }
  emscripten::val xaxisdata() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->xaxisdata));
  }
  emscripten::val yaxisdata() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->yaxisdata));
  }

 private:
  mjvFigure* ptr_;
  bool owned_ = false;
};

struct MjvGLCamera {
  ~MjvGLCamera();
  MjvGLCamera();
  explicit MjvGLCamera(mjvGLCamera *ptr);
  MjvGLCamera(const MjvGLCamera &);
  MjvGLCamera &operator=(const MjvGLCamera &);
  std::unique_ptr<MjvGLCamera> copy();
  mjvGLCamera* get() const;
  void set(mjvGLCamera* ptr);
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val forward() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->forward));
  }
  emscripten::val up() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->up));
  }
  float frustum_center() const {
    return ptr_->frustum_center;
  }
  void set_frustum_center(float value) {
    ptr_->frustum_center = value;
  }
  float frustum_width() const {
    return ptr_->frustum_width;
  }
  void set_frustum_width(float value) {
    ptr_->frustum_width = value;
  }
  float frustum_bottom() const {
    return ptr_->frustum_bottom;
  }
  void set_frustum_bottom(float value) {
    ptr_->frustum_bottom = value;
  }
  float frustum_top() const {
    return ptr_->frustum_top;
  }
  void set_frustum_top(float value) {
    ptr_->frustum_top = value;
  }
  float frustum_near() const {
    return ptr_->frustum_near;
  }
  void set_frustum_near(float value) {
    ptr_->frustum_near = value;
  }
  float frustum_far() const {
    return ptr_->frustum_far;
  }
  void set_frustum_far(float value) {
    ptr_->frustum_far = value;
  }
  int orthographic() const {
    return ptr_->orthographic;
  }
  void set_orthographic(int value) {
    ptr_->orthographic = value;
  }

 private:
  mjvGLCamera* ptr_;
  bool owned_ = false;
};

struct MjvGeom {
  ~MjvGeom();
  MjvGeom();
  explicit MjvGeom(mjvGeom *ptr);
  MjvGeom(const MjvGeom &);
  MjvGeom &operator=(const MjvGeom &);
  std::unique_ptr<MjvGeom> copy();
  mjvGeom* get() const;
  void set(mjvGeom* ptr);
  int type() const {
    return ptr_->type;
  }
  void set_type(int value) {
    ptr_->type = value;
  }
  int dataid() const {
    return ptr_->dataid;
  }
  void set_dataid(int value) {
    ptr_->dataid = value;
  }
  int objtype() const {
    return ptr_->objtype;
  }
  void set_objtype(int value) {
    ptr_->objtype = value;
  }
  int objid() const {
    return ptr_->objid;
  }
  void set_objid(int value) {
    ptr_->objid = value;
  }
  int category() const {
    return ptr_->category;
  }
  void set_category(int value) {
    ptr_->category = value;
  }
  int matid() const {
    return ptr_->matid;
  }
  void set_matid(int value) {
    ptr_->matid = value;
  }
  int texid() const {
    return ptr_->texid;
  }
  void set_texid(int value) {
    ptr_->texid = value;
  }
  int texuniform() const {
    return ptr_->texuniform;
  }
  void set_texuniform(int value) {
    ptr_->texuniform = value;
  }
  int texcoord() const {
    return ptr_->texcoord;
  }
  void set_texcoord(int value) {
    ptr_->texcoord = value;
  }
  int segid() const {
    return ptr_->segid;
  }
  void set_segid(int value) {
    ptr_->segid = value;
  }
  emscripten::val size() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val mat() const {
    return emscripten::val(emscripten::typed_memory_view(9, ptr_->mat));
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  float emission() const {
    return ptr_->emission;
  }
  void set_emission(float value) {
    ptr_->emission = value;
  }
  float specular() const {
    return ptr_->specular;
  }
  void set_specular(float value) {
    ptr_->specular = value;
  }
  float shininess() const {
    return ptr_->shininess;
  }
  void set_shininess(float value) {
    ptr_->shininess = value;
  }
  float reflectance() const {
    return ptr_->reflectance;
  }
  void set_reflectance(float value) {
    ptr_->reflectance = value;
  }
  emscripten::val texrepeat() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->texrepeat));
  }
  emscripten::val label() const {
    return emscripten::val(emscripten::typed_memory_view(100, ptr_->label));
  }
  float camdist() const {
    return ptr_->camdist;
  }
  void set_camdist(float value) {
    ptr_->camdist = value;
  }
  float modelrbound() const {
    return ptr_->modelrbound;
  }
  void set_modelrbound(float value) {
    ptr_->modelrbound = value;
  }
  mjtByte transparent() const {
    return ptr_->transparent;
  }
  void set_transparent(mjtByte value) {
    ptr_->transparent = value;
  }

 private:
  mjvGeom* ptr_;
  bool owned_ = false;
};

struct MjvLight {
  ~MjvLight();
  MjvLight();
  explicit MjvLight(mjvLight *ptr);
  MjvLight(const MjvLight &);
  MjvLight &operator=(const MjvLight &);
  std::unique_ptr<MjvLight> copy();
  mjvLight* get() const;
  void set(mjvLight* ptr);
  int id() const {
    return ptr_->id;
  }
  void set_id(int value) {
    ptr_->id = value;
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val dir() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->dir));
  }
  int type() const {
    return ptr_->type;
  }
  void set_type(int value) {
    ptr_->type = value;
  }
  int texid() const {
    return ptr_->texid;
  }
  void set_texid(int value) {
    ptr_->texid = value;
  }
  emscripten::val attenuation() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->attenuation));
  }
  float cutoff() const {
    return ptr_->cutoff;
  }
  void set_cutoff(float value) {
    ptr_->cutoff = value;
  }
  float exponent() const {
    return ptr_->exponent;
  }
  void set_exponent(float value) {
    ptr_->exponent = value;
  }
  emscripten::val ambient() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
  }
  emscripten::val diffuse() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
  }
  emscripten::val specular() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
  }
  mjtByte headlight() const {
    return ptr_->headlight;
  }
  void set_headlight(mjtByte value) {
    ptr_->headlight = value;
  }
  mjtByte castshadow() const {
    return ptr_->castshadow;
  }
  void set_castshadow(mjtByte value) {
    ptr_->castshadow = value;
  }
  float bulbradius() const {
    return ptr_->bulbradius;
  }
  void set_bulbradius(float value) {
    ptr_->bulbradius = value;
  }
  float intensity() const {
    return ptr_->intensity;
  }
  void set_intensity(float value) {
    ptr_->intensity = value;
  }
  float range() const {
    return ptr_->range;
  }
  void set_range(float value) {
    ptr_->range = value;
  }
  float softness() const {
    return ptr_->softness;
  }
  void set_softness(float value) {
    ptr_->softness = value;
  }

 private:
  mjvLight* ptr_;
  bool owned_ = false;
};

struct MjvOption {
  ~MjvOption();
  MjvOption();
  explicit MjvOption(mjvOption *ptr);
  MjvOption(const MjvOption &);
  MjvOption &operator=(const MjvOption &);
  std::unique_ptr<MjvOption> copy();
  mjvOption* get() const;
  void set(mjvOption* ptr);
  int label() const {
    return ptr_->label;
  }
  void set_label(int value) {
    ptr_->label = value;
  }
  int frame() const {
    return ptr_->frame;
  }
  void set_frame(int value) {
    ptr_->frame = value;
  }
  emscripten::val geomgroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->geomgroup));
  }
  emscripten::val sitegroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->sitegroup));
  }
  emscripten::val jointgroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->jointgroup));
  }
  emscripten::val tendongroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->tendongroup));
  }
  emscripten::val actuatorgroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->actuatorgroup));
  }
  emscripten::val flexgroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->flexgroup));
  }
  emscripten::val skingroup() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->skingroup));
  }
  emscripten::val flags() const {
    return emscripten::val(emscripten::typed_memory_view(31, ptr_->flags));
  }
  int bvh_depth() const {
    return ptr_->bvh_depth;
  }
  void set_bvh_depth(int value) {
    ptr_->bvh_depth = value;
  }
  int flex_layer() const {
    return ptr_->flex_layer;
  }
  void set_flex_layer(int value) {
    ptr_->flex_layer = value;
  }

 private:
  mjvOption* ptr_;
  bool owned_ = false;
};

struct MjvPerturb {
  ~MjvPerturb();
  MjvPerturb();
  explicit MjvPerturb(mjvPerturb *ptr);
  MjvPerturb(const MjvPerturb &);
  MjvPerturb &operator=(const MjvPerturb &);
  std::unique_ptr<MjvPerturb> copy();
  mjvPerturb* get() const;
  void set(mjvPerturb* ptr);
  int select() const {
    return ptr_->select;
  }
  void set_select(int value) {
    ptr_->select = value;
  }
  int flexselect() const {
    return ptr_->flexselect;
  }
  void set_flexselect(int value) {
    ptr_->flexselect = value;
  }
  int skinselect() const {
    return ptr_->skinselect;
  }
  void set_skinselect(int value) {
    ptr_->skinselect = value;
  }
  int active() const {
    return ptr_->active;
  }
  void set_active(int value) {
    ptr_->active = value;
  }
  int active2() const {
    return ptr_->active2;
  }
  void set_active2(int value) {
    ptr_->active2 = value;
  }
  emscripten::val refpos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->refpos));
  }
  emscripten::val refquat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->refquat));
  }
  emscripten::val refselpos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->refselpos));
  }
  emscripten::val localpos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->localpos));
  }
  mjtNum localmass() const {
    return ptr_->localmass;
  }
  void set_localmass(mjtNum value) {
    ptr_->localmass = value;
  }
  mjtNum scale() const {
    return ptr_->scale;
  }
  void set_scale(mjtNum value) {
    ptr_->scale = value;
  }

 private:
  mjvPerturb* ptr_;
  bool owned_ = false;
};

struct MjsCompiler {
  explicit MjsCompiler(mjsCompiler *ptr);
  mjsCompiler* get() const;
  void set(mjsCompiler* ptr);
  mjtBool autolimits() const {
    return ptr_->autolimits;
  }
  void set_autolimits(mjtBool value) {
    ptr_->autolimits = value;
  }
  double boundmass() const {
    return ptr_->boundmass;
  }
  void set_boundmass(double value) {
    ptr_->boundmass = value;
  }
  double boundinertia() const {
    return ptr_->boundinertia;
  }
  void set_boundinertia(double value) {
    ptr_->boundinertia = value;
  }
  double settotalmass() const {
    return ptr_->settotalmass;
  }
  void set_settotalmass(double value) {
    ptr_->settotalmass = value;
  }
  mjtBool balanceinertia() const {
    return ptr_->balanceinertia;
  }
  void set_balanceinertia(mjtBool value) {
    ptr_->balanceinertia = value;
  }
  mjtBool fitaabb() const {
    return ptr_->fitaabb;
  }
  void set_fitaabb(mjtBool value) {
    ptr_->fitaabb = value;
  }
  mjtBool degree() const {
    return ptr_->degree;
  }
  void set_degree(mjtBool value) {
    ptr_->degree = value;
  }
  emscripten::val eulerseq() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->eulerseq));
  }
  mjtBool discardvisual() const {
    return ptr_->discardvisual;
  }
  void set_discardvisual(mjtBool value) {
    ptr_->discardvisual = value;
  }
  mjtBool usethread() const {
    return ptr_->usethread;
  }
  void set_usethread(mjtBool value) {
    ptr_->usethread = value;
  }
  mjtBool fusestatic() const {
    return ptr_->fusestatic;
  }
  void set_fusestatic(mjtBool value) {
    ptr_->fusestatic = value;
  }
  mjtInertiaFromGeom inertiafromgeom() const {
    return ptr_->inertiafromgeom;
  }
  void set_inertiafromgeom(mjtInertiaFromGeom value) {
    ptr_->inertiafromgeom = value;
  }
  emscripten::val inertiagrouprange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->inertiagrouprange));
  }
  mjtBool saveinertial() const {
    return ptr_->saveinertial;
  }
  void set_saveinertial(mjtBool value) {
    ptr_->saveinertial = value;
  }
  mjtBool alignfree() const {
    return ptr_->alignfree;
  }
  void set_alignfree(mjtBool value) {
    ptr_->alignfree = value;
  }
  mjtConflict conflict() const {
    return ptr_->conflict;
  }
  void set_conflict(mjtConflict value) {
    ptr_->conflict = value;
  }
  mjString meshdir() const {
    return (ptr_ && ptr_->meshdir) ? *(ptr_->meshdir) : "";
  }
  void set_meshdir(const mjString& value) {
    if (ptr_ && ptr_->meshdir) {
      *(ptr_->meshdir) = value;
    }
  }
  mjString texturedir() const {
    return (ptr_ && ptr_->texturedir) ? *(ptr_->texturedir) : "";
  }
  void set_texturedir(const mjString& value) {
    if (ptr_ && ptr_->texturedir) {
      *(ptr_->texturedir) = value;
    }
  }
  uint64_t authored() const {
    return ptr_->authored;
  }
  void set_authored(uint64_t value) {
    ptr_->authored = value;
  }

 private:
  mjsCompiler* ptr_;

 public:
  MjLROpt LRopt;
};

struct MjVisual {
  ~MjVisual();
  MjVisual();
  explicit MjVisual(mjVisual *ptr);
  MjVisual(const MjVisual &);
  MjVisual &operator=(const MjVisual &);
  std::unique_ptr<MjVisual> copy();
  mjVisual* get() const;
  void set(mjVisual* ptr);

 private:
  mjVisual* ptr_;
  bool owned_ = false;

 public:
  MjVisualGlobal global;
  MjVisualQuality quality;
  MjVisualHeadlight headlight;
  MjVisualMap map;
  MjVisualScale scale;
  MjVisualRgba rgba;
};

struct MjsEquality {
  explicit MjsEquality(mjsEquality *ptr);
  mjsEquality* get() const;
  void set(mjsEquality* ptr);
  mjtEq type() const {
    return ptr_->type;
  }
  void set_type(mjtEq value) {
    ptr_->type = value;
  }
  emscripten::val data() const {
    return emscripten::val(emscripten::typed_memory_view(11, ptr_->data));
  }
  mjtBool active() const {
    return ptr_->active;
  }
  void set_active(mjtBool value) {
    ptr_->active = value;
  }
  mjString name1() const {
    return (ptr_ && ptr_->name1) ? *(ptr_->name1) : "";
  }
  void set_name1(const mjString& value) {
    if (ptr_ && ptr_->name1) {
      *(ptr_->name1) = value;
    }
  }
  mjString name2() const {
    return (ptr_ && ptr_->name2) ? *(ptr_->name2) : "";
  }
  void set_name2(const mjString& value) {
    if (ptr_ && ptr_->name2) {
      *(ptr_->name2) = value;
    }
  }
  mjtObj objtype() const {
    return ptr_->objtype;
  }
  void set_objtype(mjtObj value) {
    ptr_->objtype = value;
  }
  emscripten::val solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
  }
  emscripten::val solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsEquality* ptr_;

 public:
  MjsElement element;
};

struct MjsExclude {
  explicit MjsExclude(mjsExclude *ptr);
  mjsExclude* get() const;
  void set(mjsExclude* ptr);
  mjString bodyname1() const {
    return (ptr_ && ptr_->bodyname1) ? *(ptr_->bodyname1) : "";
  }
  void set_bodyname1(const mjString& value) {
    if (ptr_ && ptr_->bodyname1) {
      *(ptr_->bodyname1) = value;
    }
  }
  mjString bodyname2() const {
    return (ptr_ && ptr_->bodyname2) ? *(ptr_->bodyname2) : "";
  }
  void set_bodyname2(const mjString& value) {
    if (ptr_ && ptr_->bodyname2) {
      *(ptr_->bodyname2) = value;
    }
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsExclude* ptr_;

 public:
  MjsElement element;
};

struct MjsFlex {
  explicit MjsFlex(mjsFlex *ptr);
  mjsFlex* get() const;
  void set(mjsFlex* ptr);
  int contype() const {
    return ptr_->contype;
  }
  void set_contype(int value) {
    ptr_->contype = value;
  }
  int conaffinity() const {
    return ptr_->conaffinity;
  }
  void set_conaffinity(int value) {
    ptr_->conaffinity = value;
  }
  int condim() const {
    return ptr_->condim;
  }
  void set_condim(int value) {
    ptr_->condim = value;
  }
  int priority() const {
    return ptr_->priority;
  }
  void set_priority(int value) {
    ptr_->priority = value;
  }
  emscripten::val friction() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->friction));
  }
  double solmix() const {
    return ptr_->solmix;
  }
  void set_solmix(double value) {
    ptr_->solmix = value;
  }
  emscripten::val solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
  }
  emscripten::val solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
  }
  double margin() const {
    return ptr_->margin;
  }
  void set_margin(double value) {
    ptr_->margin = value;
  }
  double gap() const {
    return ptr_->gap;
  }
  void set_gap(double value) {
    ptr_->gap = value;
  }
  int dim() const {
    return ptr_->dim;
  }
  void set_dim(int value) {
    ptr_->dim = value;
  }
  double radius() const {
    return ptr_->radius;
  }
  void set_radius(double value) {
    ptr_->radius = value;
  }
  emscripten::val size() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
  }
  mjtBool internal() const {
    return ptr_->internal;
  }
  void set_internal(mjtBool value) {
    ptr_->internal = value;
  }
  mjtBool flatskin() const {
    return ptr_->flatskin;
  }
  void set_flatskin(mjtBool value) {
    ptr_->flatskin = value;
  }
  mjtFlexSelf selfcollide() const {
    return ptr_->selfcollide;
  }
  void set_selfcollide(mjtFlexSelf value) {
    ptr_->selfcollide = value;
  }
  int passive() const {
    return ptr_->passive;
  }
  void set_passive(int value) {
    ptr_->passive = value;
  }
  int activelayers() const {
    return ptr_->activelayers;
  }
  void set_activelayers(int value) {
    ptr_->activelayers = value;
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  double edgestiffness() const {
    return ptr_->edgestiffness;
  }
  void set_edgestiffness(double value) {
    ptr_->edgestiffness = value;
  }
  double edgedamping() const {
    return ptr_->edgedamping;
  }
  void set_edgedamping(double value) {
    ptr_->edgedamping = value;
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  double young() const {
    return ptr_->young;
  }
  void set_young(double value) {
    ptr_->young = value;
  }
  double poisson() const {
    return ptr_->poisson;
  }
  void set_poisson(double value) {
    ptr_->poisson = value;
  }
  double damping() const {
    return ptr_->damping;
  }
  void set_damping(double value) {
    ptr_->damping = value;
  }
  double thickness() const {
    return ptr_->thickness;
  }
  void set_thickness(double value) {
    ptr_->thickness = value;
  }
  int elastic2d() const {
    return ptr_->elastic2d;
  }
  void set_elastic2d(int value) {
    ptr_->elastic2d = value;
  }
  emscripten::val cellcount() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->cellcount));
  }
  int order() const {
    return ptr_->order;
  }
  void set_order(int value) {
    ptr_->order = value;
  }
  mjStringVec &nodebody() const {
    return *(ptr_->nodebody);
  }
  mjStringVec &vertbody() const {
    return *(ptr_->vertbody);
  }
  mjDoubleVec &node() const {
    return *(ptr_->node);
  }
  mjDoubleVec &vert() const {
    return *(ptr_->vert);
  }
  mjIntVec &elem() const {
    return *(ptr_->elem);
  }
  mjFloatVec &texcoord() const {
    return *(ptr_->texcoord);
  }
  mjIntVec &elemtexcoord() const {
    return *(ptr_->elemtexcoord);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsFlex* ptr_;

 public:
  MjsElement element;
};

struct MjsHField {
  explicit MjsHField(mjsHField *ptr);
  mjsHField* get() const;
  void set(mjsHField* ptr);
  mjString content_type() const {
    return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
  }
  void set_content_type(const mjString& value) {
    if (ptr_ && ptr_->content_type) {
      *(ptr_->content_type) = value;
    }
  }
  mjString file() const {
    return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
  }
  void set_file(const mjString& value) {
    if (ptr_ && ptr_->file) {
      *(ptr_->file) = value;
    }
  }
  emscripten::val size() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->size));
  }
  int nrow() const {
    return ptr_->nrow;
  }
  void set_nrow(int value) {
    ptr_->nrow = value;
  }
  int ncol() const {
    return ptr_->ncol;
  }
  void set_ncol(int value) {
    ptr_->ncol = value;
  }
  mjFloatVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsHField* ptr_;

 public:
  MjsElement element;
};

struct MjsJoint {
  explicit MjsJoint(mjsJoint *ptr);
  mjsJoint* get() const;
  void set(mjsJoint* ptr);
  mjtJoint type() const {
    return ptr_->type;
  }
  void set_type(mjtJoint value) {
    ptr_->type = value;
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val axis() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->axis));
  }
  double ref() const {
    return ptr_->ref;
  }
  void set_ref(double value) {
    ptr_->ref = value;
  }
  mjtAlignFree align() const {
    return ptr_->align;
  }
  void set_align(mjtAlignFree value) {
    ptr_->align = value;
  }
  emscripten::val stiffness() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->stiffness));
  }
  double springref() const {
    return ptr_->springref;
  }
  void set_springref(double value) {
    ptr_->springref = value;
  }
  emscripten::val springdamper() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->springdamper));
  }
  mjtLimited limited() const {
    return ptr_->limited;
  }
  void set_limited(mjtLimited value) {
    ptr_->limited = value;
  }
  emscripten::val range() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->range));
  }
  double margin() const {
    return ptr_->margin;
  }
  void set_margin(double value) {
    ptr_->margin = value;
  }
  emscripten::val solref_limit() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_limit));
  }
  emscripten::val solimp_limit() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_limit));
  }
  mjtLimited actfrclimited() const {
    return ptr_->actfrclimited;
  }
  void set_actfrclimited(mjtLimited value) {
    ptr_->actfrclimited = value;
  }
  emscripten::val actfrcrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->actfrcrange));
  }
  double armature() const {
    return ptr_->armature;
  }
  void set_armature(double value) {
    ptr_->armature = value;
  }
  emscripten::val damping() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
  }
  double frictionloss() const {
    return ptr_->frictionloss;
  }
  void set_frictionloss(double value) {
    ptr_->frictionloss = value;
  }
  emscripten::val solref_friction() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_friction));
  }
  emscripten::val solimp_friction() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_friction));
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  mjtBool actgravcomp() const {
    return ptr_->actgravcomp;
  }
  void set_actgravcomp(mjtBool value) {
    ptr_->actgravcomp = value;
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsJoint* ptr_;

 public:
  MjsElement element;
};

struct MjsKey {
  explicit MjsKey(mjsKey *ptr);
  mjsKey* get() const;
  void set(mjsKey* ptr);
  double time() const {
    return ptr_->time;
  }
  void set_time(double value) {
    ptr_->time = value;
  }
  mjDoubleVec &qpos() const {
    return *(ptr_->qpos);
  }
  mjDoubleVec &qvel() const {
    return *(ptr_->qvel);
  }
  mjDoubleVec &act() const {
    return *(ptr_->act);
  }
  mjDoubleVec &mpos() const {
    return *(ptr_->mpos);
  }
  mjDoubleVec &mquat() const {
    return *(ptr_->mquat);
  }
  mjDoubleVec &ctrl() const {
    return *(ptr_->ctrl);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsKey* ptr_;

 public:
  MjsElement element;
};

struct MjsLight {
  explicit MjsLight(mjsLight *ptr);
  mjsLight* get() const;
  void set(mjsLight* ptr);
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val dir() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->dir));
  }
  mjtCamLight mode() const {
    return ptr_->mode;
  }
  void set_mode(mjtCamLight value) {
    ptr_->mode = value;
  }
  mjString targetbody() const {
    return (ptr_ && ptr_->targetbody) ? *(ptr_->targetbody) : "";
  }
  void set_targetbody(const mjString& value) {
    if (ptr_ && ptr_->targetbody) {
      *(ptr_->targetbody) = value;
    }
  }
  mjtBool active() const {
    return ptr_->active;
  }
  void set_active(mjtBool value) {
    ptr_->active = value;
  }
  mjtLightType type() const {
    return ptr_->type;
  }
  void set_type(mjtLightType value) {
    ptr_->type = value;
  }
  mjString texture() const {
    return (ptr_ && ptr_->texture) ? *(ptr_->texture) : "";
  }
  void set_texture(const mjString& value) {
    if (ptr_ && ptr_->texture) {
      *(ptr_->texture) = value;
    }
  }
  mjtBool castshadow() const {
    return ptr_->castshadow;
  }
  void set_castshadow(mjtBool value) {
    ptr_->castshadow = value;
  }
  float bulbradius() const {
    return ptr_->bulbradius;
  }
  void set_bulbradius(float value) {
    ptr_->bulbradius = value;
  }
  float intensity() const {
    return ptr_->intensity;
  }
  void set_intensity(float value) {
    ptr_->intensity = value;
  }
  float range() const {
    return ptr_->range;
  }
  void set_range(float value) {
    ptr_->range = value;
  }
  emscripten::val attenuation() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->attenuation));
  }
  float cutoff() const {
    return ptr_->cutoff;
  }
  void set_cutoff(float value) {
    ptr_->cutoff = value;
  }
  float softness() const {
    return ptr_->softness;
  }
  void set_softness(float value) {
    ptr_->softness = value;
  }
  float exponent() const {
    return ptr_->exponent;
  }
  void set_exponent(float value) {
    ptr_->exponent = value;
  }
  emscripten::val ambient() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
  }
  emscripten::val diffuse() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
  }
  emscripten::val specular() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsLight* ptr_;

 public:
  MjsElement element;
};

struct MjsMaterial {
  explicit MjsMaterial(mjsMaterial *ptr);
  mjsMaterial* get() const;
  void set(mjsMaterial* ptr);
  mjStringVec &textures() const {
    return *(ptr_->textures);
  }
  mjtBool texuniform() const {
    return ptr_->texuniform;
  }
  void set_texuniform(mjtBool value) {
    ptr_->texuniform = value;
  }
  emscripten::val texrepeat() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->texrepeat));
  }
  float emission() const {
    return ptr_->emission;
  }
  void set_emission(float value) {
    ptr_->emission = value;
  }
  float specular() const {
    return ptr_->specular;
  }
  void set_specular(float value) {
    ptr_->specular = value;
  }
  float shininess() const {
    return ptr_->shininess;
  }
  void set_shininess(float value) {
    ptr_->shininess = value;
  }
  float reflectance() const {
    return ptr_->reflectance;
  }
  void set_reflectance(float value) {
    ptr_->reflectance = value;
  }
  float metallic() const {
    return ptr_->metallic;
  }
  void set_metallic(float value) {
    ptr_->metallic = value;
  }
  float roughness() const {
    return ptr_->roughness;
  }
  void set_roughness(float value) {
    ptr_->roughness = value;
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsMaterial* ptr_;

 public:
  MjsElement element;
};

struct MjsNumeric {
  explicit MjsNumeric(mjsNumeric *ptr);
  mjsNumeric* get() const;
  void set(mjsNumeric* ptr);
  mjDoubleVec &data() const {
    return *(ptr_->data);
  }
  int size() const {
    return ptr_->size;
  }
  void set_size(int value) {
    ptr_->size = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsNumeric* ptr_;

 public:
  MjsElement element;
};

struct MjsPair {
  explicit MjsPair(mjsPair *ptr);
  mjsPair* get() const;
  void set(mjsPair* ptr);
  mjString geomname1() const {
    return (ptr_ && ptr_->geomname1) ? *(ptr_->geomname1) : "";
  }
  void set_geomname1(const mjString& value) {
    if (ptr_ && ptr_->geomname1) {
      *(ptr_->geomname1) = value;
    }
  }
  mjString geomname2() const {
    return (ptr_ && ptr_->geomname2) ? *(ptr_->geomname2) : "";
  }
  void set_geomname2(const mjString& value) {
    if (ptr_ && ptr_->geomname2) {
      *(ptr_->geomname2) = value;
    }
  }
  int condim() const {
    return ptr_->condim;
  }
  void set_condim(int value) {
    ptr_->condim = value;
  }
  emscripten::val solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
  }
  emscripten::val solreffriction() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solreffriction));
  }
  emscripten::val solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
  }
  double margin() const {
    return ptr_->margin;
  }
  void set_margin(double value) {
    ptr_->margin = value;
  }
  double gap() const {
    return ptr_->gap;
  }
  void set_gap(double value) {
    ptr_->gap = value;
  }
  double adhesion() const {
    return ptr_->adhesion;
  }
  void set_adhesion(double value) {
    ptr_->adhesion = value;
  }
  emscripten::val friction() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->friction));
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsPair* ptr_;

 public:
  MjsElement element;
};

struct MjsPlugin {
  explicit MjsPlugin(mjsPlugin *ptr);
  mjsPlugin* get() const;
  void set(mjsPlugin* ptr);
  mjString name() const {
    return (ptr_ && ptr_->name) ? *(ptr_->name) : "";
  }
  void set_name(const mjString& value) {
    if (ptr_ && ptr_->name) {
      *(ptr_->name) = value;
    }
  }
  mjString plugin_name() const {
    return (ptr_ && ptr_->plugin_name) ? *(ptr_->plugin_name) : "";
  }
  void set_plugin_name(const mjString& value) {
    if (ptr_ && ptr_->plugin_name) {
      *(ptr_->plugin_name) = value;
    }
  }
  mjtBool active() const {
    return ptr_->active;
  }
  void set_active(mjtBool value) {
    ptr_->active = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsPlugin* ptr_;

 public:
  MjsElement element;
};

struct MjsSkin {
  explicit MjsSkin(mjsSkin *ptr);
  mjsSkin* get() const;
  void set(mjsSkin* ptr);
  mjString file() const {
    return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
  }
  void set_file(const mjString& value) {
    if (ptr_ && ptr_->file) {
      *(ptr_->file) = value;
    }
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  float inflate() const {
    return ptr_->inflate;
  }
  void set_inflate(float value) {
    ptr_->inflate = value;
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  mjFloatVec &vert() const {
    return *(ptr_->vert);
  }
  mjFloatVec &texcoord() const {
    return *(ptr_->texcoord);
  }
  mjIntVec &face() const {
    return *(ptr_->face);
  }
  mjStringVec &bodyname() const {
    return *(ptr_->bodyname);
  }
  mjFloatVec &bindpos() const {
    return *(ptr_->bindpos);
  }
  mjFloatVec &bindquat() const {
    return *(ptr_->bindquat);
  }
  mjIntVecVec &vertid() const {
    return *(ptr_->vertid);
  }
  mjFloatVecVec &vertweight() const {
    return *(ptr_->vertweight);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsSkin* ptr_;

 public:
  MjsElement element;
};

struct MjsTendon {
  explicit MjsTendon(mjsTendon *ptr);
  mjsTendon* get() const;
  void set(mjsTendon* ptr);
  emscripten::val stiffness() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->stiffness));
  }
  emscripten::val springlength() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->springlength));
  }
  emscripten::val damping() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
  }
  double frictionloss() const {
    return ptr_->frictionloss;
  }
  void set_frictionloss(double value) {
    ptr_->frictionloss = value;
  }
  emscripten::val solref_friction() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_friction));
  }
  emscripten::val solimp_friction() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_friction));
  }
  double armature() const {
    return ptr_->armature;
  }
  void set_armature(double value) {
    ptr_->armature = value;
  }
  mjtLimited limited() const {
    return ptr_->limited;
  }
  void set_limited(mjtLimited value) {
    ptr_->limited = value;
  }
  mjtLimited actfrclimited() const {
    return ptr_->actfrclimited;
  }
  void set_actfrclimited(mjtLimited value) {
    ptr_->actfrclimited = value;
  }
  emscripten::val range() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->range));
  }
  emscripten::val actfrcrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->actfrcrange));
  }
  double margin() const {
    return ptr_->margin;
  }
  void set_margin(double value) {
    ptr_->margin = value;
  }
  emscripten::val solref_limit() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_limit));
  }
  emscripten::val solimp_limit() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_limit));
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  double width() const {
    return ptr_->width;
  }
  void set_width(double value) {
    ptr_->width = value;
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsTendon* ptr_;

 public:
  MjsElement element;
};

struct MjsText {
  explicit MjsText(mjsText *ptr);
  mjsText* get() const;
  void set(mjsText* ptr);
  mjString data() const {
    return (ptr_ && ptr_->data) ? *(ptr_->data) : "";
  }
  void set_data(const mjString& value) {
    if (ptr_ && ptr_->data) {
      *(ptr_->data) = value;
    }
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsText* ptr_;

 public:
  MjsElement element;
};

struct MjsTexture {
  explicit MjsTexture(mjsTexture *ptr);
  mjsTexture* get() const;
  void set(mjsTexture* ptr);
  mjtTexture type() const {
    return ptr_->type;
  }
  void set_type(mjtTexture value) {
    ptr_->type = value;
  }
  mjtColorSpace colorspace() const {
    return ptr_->colorspace;
  }
  void set_colorspace(mjtColorSpace value) {
    ptr_->colorspace = value;
  }
  mjtBuiltin builtin() const {
    return ptr_->builtin;
  }
  void set_builtin(mjtBuiltin value) {
    ptr_->builtin = value;
  }
  mjtMark mark() const {
    return ptr_->mark;
  }
  void set_mark(mjtMark value) {
    ptr_->mark = value;
  }
  emscripten::val rgb1() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->rgb1));
  }
  emscripten::val rgb2() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->rgb2));
  }
  emscripten::val markrgb() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->markrgb));
  }
  double random() const {
    return ptr_->random;
  }
  void set_random(double value) {
    ptr_->random = value;
  }
  int height() const {
    return ptr_->height;
  }
  void set_height(int value) {
    ptr_->height = value;
  }
  int width() const {
    return ptr_->width;
  }
  void set_width(int value) {
    ptr_->width = value;
  }
  int nchannel() const {
    return ptr_->nchannel;
  }
  void set_nchannel(int value) {
    ptr_->nchannel = value;
  }
  mjString content_type() const {
    return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
  }
  void set_content_type(const mjString& value) {
    if (ptr_ && ptr_->content_type) {
      *(ptr_->content_type) = value;
    }
  }
  mjString file() const {
    return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
  }
  void set_file(const mjString& value) {
    if (ptr_ && ptr_->file) {
      *(ptr_->file) = value;
    }
  }
  emscripten::val gridsize() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->gridsize));
  }
  emscripten::val gridlayout() const {
    return emscripten::val(emscripten::typed_memory_view(12, ptr_->gridlayout));
  }
  mjStringVec &cubefiles() const {
    return *(ptr_->cubefiles);
  }
  std::vector<uint8_t> &data() const {
    return *(reinterpret_cast<std::vector<uint8_t>*>(ptr_->data));
  }
  mjtBool hflip() const {
    return ptr_->hflip;
  }
  void set_hflip(mjtBool value) {
    ptr_->hflip = value;
  }
  mjtBool vflip() const {
    return ptr_->vflip;
  }
  void set_vflip(mjtBool value) {
    ptr_->vflip = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsTexture* ptr_;

 public:
  MjsElement element;
};

struct MjsTuple {
  explicit MjsTuple(mjsTuple *ptr);
  mjsTuple* get() const;
  void set(mjsTuple* ptr);
  mjIntVec &objtype() const {
    return *(ptr_->objtype);
  }
  mjStringVec &objname() const {
    return *(ptr_->objname);
  }
  mjDoubleVec &objprm() const {
    return *(ptr_->objprm);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsTuple* ptr_;

 public:
  MjsElement element;
};

struct MjsWrap {
  explicit MjsWrap(mjsWrap *ptr);
  mjsWrap* get() const;
  void set(mjsWrap* ptr);
  mjtWrap type() const {
    return ptr_->type;
  }
  void set_type(mjtWrap value) {
    ptr_->type = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsWrap* ptr_;

 public:
  MjsElement element;
};

struct MjsCamera {
  explicit MjsCamera(mjsCamera *ptr);
  mjsCamera* get() const;
  void set(mjsCamera* ptr);
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val quat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
  }
  mjtCamLight mode() const {
    return ptr_->mode;
  }
  void set_mode(mjtCamLight value) {
    ptr_->mode = value;
  }
  mjString targetbody() const {
    return (ptr_ && ptr_->targetbody) ? *(ptr_->targetbody) : "";
  }
  void set_targetbody(const mjString& value) {
    if (ptr_ && ptr_->targetbody) {
      *(ptr_->targetbody) = value;
    }
  }
  mjtProjection proj() const {
    return ptr_->proj;
  }
  void set_proj(mjtProjection value) {
    ptr_->proj = value;
  }
  emscripten::val resolution() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->resolution));
  }
  int output() const {
    return ptr_->output;
  }
  void set_output(int value) {
    ptr_->output = value;
  }
  double fovy() const {
    return ptr_->fovy;
  }
  void set_fovy(double value) {
    ptr_->fovy = value;
  }
  double ipd() const {
    return ptr_->ipd;
  }
  void set_ipd(double value) {
    ptr_->ipd = value;
  }
  emscripten::val intrinsic() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->intrinsic));
  }
  emscripten::val sensor_size() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->sensor_size));
  }
  emscripten::val focal_length() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->focal_length));
  }
  emscripten::val focal_pixel() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->focal_pixel));
  }
  emscripten::val principal_length() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->principal_length));
  }
  emscripten::val principal_pixel() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->principal_pixel));
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsCamera* ptr_;

 public:
  MjsElement element;
  MjsOrientation alt;
};

struct MjsFrame {
  explicit MjsFrame(mjsFrame *ptr);
  mjsFrame* get() const;
  void set(mjsFrame* ptr);
  mjString childclass() const {
    return (ptr_ && ptr_->childclass) ? *(ptr_->childclass) : "";
  }
  void set_childclass(const mjString& value) {
    if (ptr_ && ptr_->childclass) {
      *(ptr_->childclass) = value;
    }
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val quat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsFrame* ptr_;

 public:
  MjsElement element;
  MjsOrientation alt;
};

struct MjsSite {
  explicit MjsSite(mjsSite *ptr);
  mjsSite* get() const;
  void set(mjsSite* ptr);
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val quat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
  }
  emscripten::val fromto() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->fromto));
  }
  emscripten::val size() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
  }
  mjtGeom type() const {
    return ptr_->type;
  }
  void set_type(mjtGeom value) {
    ptr_->type = value;
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsSite* ptr_;

 public:
  MjsElement element;
  MjsOrientation alt;
};

struct MjModel {
  ~MjModel();
  explicit MjModel(mjModel *ptr);
  MjModel(const MjModel &);
  std::unique_ptr<MjModel> copy();
  mjModel* get() const;
  void set(mjModel* ptr);
  int nq() const {
    return static_cast<int>(ptr_->nq);
  }
  void set_nq(int value) {
    ptr_->nq = static_cast<mjtSize>(value);
  }
  int nv() const {
    return static_cast<int>(ptr_->nv);
  }
  void set_nv(int value) {
    ptr_->nv = static_cast<mjtSize>(value);
  }
  int nu() const {
    return static_cast<int>(ptr_->nu);
  }
  void set_nu(int value) {
    ptr_->nu = static_cast<mjtSize>(value);
  }
  int nactuator() const {
    return static_cast<int>(ptr_->nactuator);
  }
  void set_nactuator(int value) {
    ptr_->nactuator = static_cast<mjtSize>(value);
  }
  int nout() const {
    return static_cast<int>(ptr_->nout);
  }
  void set_nout(int value) {
    ptr_->nout = static_cast<mjtSize>(value);
  }
  int na() const {
    return static_cast<int>(ptr_->na);
  }
  void set_na(int value) {
    ptr_->na = static_cast<mjtSize>(value);
  }
  int nbody() const {
    return static_cast<int>(ptr_->nbody);
  }
  void set_nbody(int value) {
    ptr_->nbody = static_cast<mjtSize>(value);
  }
  int nbvh() const {
    return static_cast<int>(ptr_->nbvh);
  }
  void set_nbvh(int value) {
    ptr_->nbvh = static_cast<mjtSize>(value);
  }
  int nbvhstatic() const {
    return static_cast<int>(ptr_->nbvhstatic);
  }
  void set_nbvhstatic(int value) {
    ptr_->nbvhstatic = static_cast<mjtSize>(value);
  }
  int nbvhdynamic() const {
    return static_cast<int>(ptr_->nbvhdynamic);
  }
  void set_nbvhdynamic(int value) {
    ptr_->nbvhdynamic = static_cast<mjtSize>(value);
  }
  int noct() const {
    return static_cast<int>(ptr_->noct);
  }
  void set_noct(int value) {
    ptr_->noct = static_cast<mjtSize>(value);
  }
  int njnt() const {
    return static_cast<int>(ptr_->njnt);
  }
  void set_njnt(int value) {
    ptr_->njnt = static_cast<mjtSize>(value);
  }
  int ntree() const {
    return static_cast<int>(ptr_->ntree);
  }
  void set_ntree(int value) {
    ptr_->ntree = static_cast<mjtSize>(value);
  }
  int nM() const {
    return static_cast<int>(ptr_->nM);
  }
  void set_nM(int value) {
    ptr_->nM = static_cast<mjtSize>(value);
  }
  int nB() const {
    return static_cast<int>(ptr_->nB);
  }
  void set_nB(int value) {
    ptr_->nB = static_cast<mjtSize>(value);
  }
  int nC() const {
    return static_cast<int>(ptr_->nC);
  }
  void set_nC(int value) {
    ptr_->nC = static_cast<mjtSize>(value);
  }
  int nD() const {
    return static_cast<int>(ptr_->nD);
  }
  void set_nD(int value) {
    ptr_->nD = static_cast<mjtSize>(value);
  }
  int ngeom() const {
    return static_cast<int>(ptr_->ngeom);
  }
  void set_ngeom(int value) {
    ptr_->ngeom = static_cast<mjtSize>(value);
  }
  int nsite() const {
    return static_cast<int>(ptr_->nsite);
  }
  void set_nsite(int value) {
    ptr_->nsite = static_cast<mjtSize>(value);
  }
  int ncam() const {
    return static_cast<int>(ptr_->ncam);
  }
  void set_ncam(int value) {
    ptr_->ncam = static_cast<mjtSize>(value);
  }
  int nlight() const {
    return static_cast<int>(ptr_->nlight);
  }
  void set_nlight(int value) {
    ptr_->nlight = static_cast<mjtSize>(value);
  }
  int nflex() const {
    return static_cast<int>(ptr_->nflex);
  }
  void set_nflex(int value) {
    ptr_->nflex = static_cast<mjtSize>(value);
  }
  int nflexnode() const {
    return static_cast<int>(ptr_->nflexnode);
  }
  void set_nflexnode(int value) {
    ptr_->nflexnode = static_cast<mjtSize>(value);
  }
  int nflexvert() const {
    return static_cast<int>(ptr_->nflexvert);
  }
  void set_nflexvert(int value) {
    ptr_->nflexvert = static_cast<mjtSize>(value);
  }
  int nflexedge() const {
    return static_cast<int>(ptr_->nflexedge);
  }
  void set_nflexedge(int value) {
    ptr_->nflexedge = static_cast<mjtSize>(value);
  }
  int nflexelem() const {
    return static_cast<int>(ptr_->nflexelem);
  }
  void set_nflexelem(int value) {
    ptr_->nflexelem = static_cast<mjtSize>(value);
  }
  int nflexelemdata() const {
    return static_cast<int>(ptr_->nflexelemdata);
  }
  void set_nflexelemdata(int value) {
    ptr_->nflexelemdata = static_cast<mjtSize>(value);
  }
  int nflexstiffness() const {
    return static_cast<int>(ptr_->nflexstiffness);
  }
  void set_nflexstiffness(int value) {
    ptr_->nflexstiffness = static_cast<mjtSize>(value);
  }
  int nflexbending() const {
    return static_cast<int>(ptr_->nflexbending);
  }
  void set_nflexbending(int value) {
    ptr_->nflexbending = static_cast<mjtSize>(value);
  }
  int nefm0dof() const {
    return static_cast<int>(ptr_->nefm0dof);
  }
  void set_nefm0dof(int value) {
    ptr_->nefm0dof = static_cast<mjtSize>(value);
  }
  int nefm0L() const {
    return static_cast<int>(ptr_->nefm0L);
  }
  void set_nefm0L(int value) {
    ptr_->nefm0L = static_cast<mjtSize>(value);
  }
  int nflexelemedge() const {
    return static_cast<int>(ptr_->nflexelemedge);
  }
  void set_nflexelemedge(int value) {
    ptr_->nflexelemedge = static_cast<mjtSize>(value);
  }
  int nflexshelldata() const {
    return static_cast<int>(ptr_->nflexshelldata);
  }
  void set_nflexshelldata(int value) {
    ptr_->nflexshelldata = static_cast<mjtSize>(value);
  }
  int nflexevpair() const {
    return static_cast<int>(ptr_->nflexevpair);
  }
  void set_nflexevpair(int value) {
    ptr_->nflexevpair = static_cast<mjtSize>(value);
  }
  int nflextexcoord() const {
    return static_cast<int>(ptr_->nflextexcoord);
  }
  void set_nflextexcoord(int value) {
    ptr_->nflextexcoord = static_cast<mjtSize>(value);
  }
  int nJfe() const {
    return static_cast<int>(ptr_->nJfe);
  }
  void set_nJfe(int value) {
    ptr_->nJfe = static_cast<mjtSize>(value);
  }
  int nJfv() const {
    return static_cast<int>(ptr_->nJfv);
  }
  void set_nJfv(int value) {
    ptr_->nJfv = static_cast<mjtSize>(value);
  }
  int nmesh() const {
    return static_cast<int>(ptr_->nmesh);
  }
  void set_nmesh(int value) {
    ptr_->nmesh = static_cast<mjtSize>(value);
  }
  int nmeshvert() const {
    return static_cast<int>(ptr_->nmeshvert);
  }
  void set_nmeshvert(int value) {
    ptr_->nmeshvert = static_cast<mjtSize>(value);
  }
  int nmeshnormal() const {
    return static_cast<int>(ptr_->nmeshnormal);
  }
  void set_nmeshnormal(int value) {
    ptr_->nmeshnormal = static_cast<mjtSize>(value);
  }
  int nmeshtexcoord() const {
    return static_cast<int>(ptr_->nmeshtexcoord);
  }
  void set_nmeshtexcoord(int value) {
    ptr_->nmeshtexcoord = static_cast<mjtSize>(value);
  }
  int nmeshface() const {
    return static_cast<int>(ptr_->nmeshface);
  }
  void set_nmeshface(int value) {
    ptr_->nmeshface = static_cast<mjtSize>(value);
  }
  int nmeshgraph() const {
    return static_cast<int>(ptr_->nmeshgraph);
  }
  void set_nmeshgraph(int value) {
    ptr_->nmeshgraph = static_cast<mjtSize>(value);
  }
  int nmeshpoly() const {
    return static_cast<int>(ptr_->nmeshpoly);
  }
  void set_nmeshpoly(int value) {
    ptr_->nmeshpoly = static_cast<mjtSize>(value);
  }
  int nmeshpolyvert() const {
    return static_cast<int>(ptr_->nmeshpolyvert);
  }
  void set_nmeshpolyvert(int value) {
    ptr_->nmeshpolyvert = static_cast<mjtSize>(value);
  }
  int nmeshpolymap() const {
    return static_cast<int>(ptr_->nmeshpolymap);
  }
  void set_nmeshpolymap(int value) {
    ptr_->nmeshpolymap = static_cast<mjtSize>(value);
  }
  int nskin() const {
    return static_cast<int>(ptr_->nskin);
  }
  void set_nskin(int value) {
    ptr_->nskin = static_cast<mjtSize>(value);
  }
  int nskinvert() const {
    return static_cast<int>(ptr_->nskinvert);
  }
  void set_nskinvert(int value) {
    ptr_->nskinvert = static_cast<mjtSize>(value);
  }
  int nskintexvert() const {
    return static_cast<int>(ptr_->nskintexvert);
  }
  void set_nskintexvert(int value) {
    ptr_->nskintexvert = static_cast<mjtSize>(value);
  }
  int nskinface() const {
    return static_cast<int>(ptr_->nskinface);
  }
  void set_nskinface(int value) {
    ptr_->nskinface = static_cast<mjtSize>(value);
  }
  int nskinbone() const {
    return static_cast<int>(ptr_->nskinbone);
  }
  void set_nskinbone(int value) {
    ptr_->nskinbone = static_cast<mjtSize>(value);
  }
  int nskinbonevert() const {
    return static_cast<int>(ptr_->nskinbonevert);
  }
  void set_nskinbonevert(int value) {
    ptr_->nskinbonevert = static_cast<mjtSize>(value);
  }
  int nhfield() const {
    return static_cast<int>(ptr_->nhfield);
  }
  void set_nhfield(int value) {
    ptr_->nhfield = static_cast<mjtSize>(value);
  }
  int nhfielddata() const {
    return static_cast<int>(ptr_->nhfielddata);
  }
  void set_nhfielddata(int value) {
    ptr_->nhfielddata = static_cast<mjtSize>(value);
  }
  int ntex() const {
    return static_cast<int>(ptr_->ntex);
  }
  void set_ntex(int value) {
    ptr_->ntex = static_cast<mjtSize>(value);
  }
  int ntexdata() const {
    return static_cast<int>(ptr_->ntexdata);
  }
  void set_ntexdata(int value) {
    ptr_->ntexdata = static_cast<mjtSize>(value);
  }
  int nmat() const {
    return static_cast<int>(ptr_->nmat);
  }
  void set_nmat(int value) {
    ptr_->nmat = static_cast<mjtSize>(value);
  }
  int npair() const {
    return static_cast<int>(ptr_->npair);
  }
  void set_npair(int value) {
    ptr_->npair = static_cast<mjtSize>(value);
  }
  int nexclude() const {
    return static_cast<int>(ptr_->nexclude);
  }
  void set_nexclude(int value) {
    ptr_->nexclude = static_cast<mjtSize>(value);
  }
  int neq() const {
    return static_cast<int>(ptr_->neq);
  }
  void set_neq(int value) {
    ptr_->neq = static_cast<mjtSize>(value);
  }
  int ntendon() const {
    return static_cast<int>(ptr_->ntendon);
  }
  void set_ntendon(int value) {
    ptr_->ntendon = static_cast<mjtSize>(value);
  }
  int nJten() const {
    return static_cast<int>(ptr_->nJten);
  }
  void set_nJten(int value) {
    ptr_->nJten = static_cast<mjtSize>(value);
  }
  int nwrap() const {
    return static_cast<int>(ptr_->nwrap);
  }
  void set_nwrap(int value) {
    ptr_->nwrap = static_cast<mjtSize>(value);
  }
  int nsensor() const {
    return static_cast<int>(ptr_->nsensor);
  }
  void set_nsensor(int value) {
    ptr_->nsensor = static_cast<mjtSize>(value);
  }
  int nnumeric() const {
    return static_cast<int>(ptr_->nnumeric);
  }
  void set_nnumeric(int value) {
    ptr_->nnumeric = static_cast<mjtSize>(value);
  }
  int nnumericdata() const {
    return static_cast<int>(ptr_->nnumericdata);
  }
  void set_nnumericdata(int value) {
    ptr_->nnumericdata = static_cast<mjtSize>(value);
  }
  int ntext() const {
    return static_cast<int>(ptr_->ntext);
  }
  void set_ntext(int value) {
    ptr_->ntext = static_cast<mjtSize>(value);
  }
  int ntextdata() const {
    return static_cast<int>(ptr_->ntextdata);
  }
  void set_ntextdata(int value) {
    ptr_->ntextdata = static_cast<mjtSize>(value);
  }
  int ntuple() const {
    return static_cast<int>(ptr_->ntuple);
  }
  void set_ntuple(int value) {
    ptr_->ntuple = static_cast<mjtSize>(value);
  }
  int ntupledata() const {
    return static_cast<int>(ptr_->ntupledata);
  }
  void set_ntupledata(int value) {
    ptr_->ntupledata = static_cast<mjtSize>(value);
  }
  int nkey() const {
    return static_cast<int>(ptr_->nkey);
  }
  void set_nkey(int value) {
    ptr_->nkey = static_cast<mjtSize>(value);
  }
  int nmocap() const {
    return static_cast<int>(ptr_->nmocap);
  }
  void set_nmocap(int value) {
    ptr_->nmocap = static_cast<mjtSize>(value);
  }
  int nplugin() const {
    return static_cast<int>(ptr_->nplugin);
  }
  void set_nplugin(int value) {
    ptr_->nplugin = static_cast<mjtSize>(value);
  }
  int npluginattr() const {
    return static_cast<int>(ptr_->npluginattr);
  }
  void set_npluginattr(int value) {
    ptr_->npluginattr = static_cast<mjtSize>(value);
  }
  int nuser_body() const {
    return static_cast<int>(ptr_->nuser_body);
  }
  void set_nuser_body(int value) {
    ptr_->nuser_body = static_cast<mjtSize>(value);
  }
  int nuser_jnt() const {
    return static_cast<int>(ptr_->nuser_jnt);
  }
  void set_nuser_jnt(int value) {
    ptr_->nuser_jnt = static_cast<mjtSize>(value);
  }
  int nuser_geom() const {
    return static_cast<int>(ptr_->nuser_geom);
  }
  void set_nuser_geom(int value) {
    ptr_->nuser_geom = static_cast<mjtSize>(value);
  }
  int nuser_site() const {
    return static_cast<int>(ptr_->nuser_site);
  }
  void set_nuser_site(int value) {
    ptr_->nuser_site = static_cast<mjtSize>(value);
  }
  int nuser_cam() const {
    return static_cast<int>(ptr_->nuser_cam);
  }
  void set_nuser_cam(int value) {
    ptr_->nuser_cam = static_cast<mjtSize>(value);
  }
  int nuser_tendon() const {
    return static_cast<int>(ptr_->nuser_tendon);
  }
  void set_nuser_tendon(int value) {
    ptr_->nuser_tendon = static_cast<mjtSize>(value);
  }
  int nuser_actuator() const {
    return static_cast<int>(ptr_->nuser_actuator);
  }
  void set_nuser_actuator(int value) {
    ptr_->nuser_actuator = static_cast<mjtSize>(value);
  }
  int nuser_sensor() const {
    return static_cast<int>(ptr_->nuser_sensor);
  }
  void set_nuser_sensor(int value) {
    ptr_->nuser_sensor = static_cast<mjtSize>(value);
  }
  int nnames() const {
    return static_cast<int>(ptr_->nnames);
  }
  void set_nnames(int value) {
    ptr_->nnames = static_cast<mjtSize>(value);
  }
  int npaths() const {
    return static_cast<int>(ptr_->npaths);
  }
  void set_npaths(int value) {
    ptr_->npaths = static_cast<mjtSize>(value);
  }
  int nnames_map() const {
    return static_cast<int>(ptr_->nnames_map);
  }
  void set_nnames_map(int value) {
    ptr_->nnames_map = static_cast<mjtSize>(value);
  }
  int nJmom() const {
    return static_cast<int>(ptr_->nJmom);
  }
  void set_nJmom(int value) {
    ptr_->nJmom = static_cast<mjtSize>(value);
  }
  int ngravcomp() const {
    return static_cast<int>(ptr_->ngravcomp);
  }
  void set_ngravcomp(int value) {
    ptr_->ngravcomp = static_cast<mjtSize>(value);
  }
  int nemax() const {
    return static_cast<int>(ptr_->nemax);
  }
  void set_nemax(int value) {
    ptr_->nemax = static_cast<mjtSize>(value);
  }
  int njmax() const {
    return static_cast<int>(ptr_->njmax);
  }
  void set_njmax(int value) {
    ptr_->njmax = static_cast<mjtSize>(value);
  }
  int nconmax() const {
    return static_cast<int>(ptr_->nconmax);
  }
  void set_nconmax(int value) {
    ptr_->nconmax = static_cast<mjtSize>(value);
  }
  int npolygonmax() const {
    return static_cast<int>(ptr_->npolygonmax);
  }
  void set_npolygonmax(int value) {
    ptr_->npolygonmax = static_cast<mjtSize>(value);
  }
  int nmeshdegmax() const {
    return static_cast<int>(ptr_->nmeshdegmax);
  }
  void set_nmeshdegmax(int value) {
    ptr_->nmeshdegmax = static_cast<mjtSize>(value);
  }
  int nuserdata() const {
    return static_cast<int>(ptr_->nuserdata);
  }
  void set_nuserdata(int value) {
    ptr_->nuserdata = static_cast<mjtSize>(value);
  }
  int nsensordata() const {
    return static_cast<int>(ptr_->nsensordata);
  }
  void set_nsensordata(int value) {
    ptr_->nsensordata = static_cast<mjtSize>(value);
  }
  int npluginstate() const {
    return static_cast<int>(ptr_->npluginstate);
  }
  void set_npluginstate(int value) {
    ptr_->npluginstate = static_cast<mjtSize>(value);
  }
  int nhistory() const {
    return static_cast<int>(ptr_->nhistory);
  }
  void set_nhistory(int value) {
    ptr_->nhistory = static_cast<mjtSize>(value);
  }
  int narena() const {
    return static_cast<int>(ptr_->narena);
  }
  void set_narena(int value) {
    ptr_->narena = static_cast<mjtSize>(value);
  }
  int nbuffer() const {
    return static_cast<int>(ptr_->nbuffer);
  }
  void set_nbuffer(int value) {
    ptr_->nbuffer = static_cast<mjtSize>(value);
  }
  mjtBool flg_gravcomp() const {
    return ptr_->flg_gravcomp;
  }
  void set_flg_gravcomp(mjtBool value) {
    ptr_->flg_gravcomp = value;
  }
  mjtBool flg_surfacevel() const {
    return ptr_->flg_surfacevel;
  }
  void set_flg_surfacevel(mjtBool value) {
    ptr_->flg_surfacevel = value;
  }
  mjtBool flg_adhesion() const {
    return ptr_->flg_adhesion;
  }
  void set_flg_adhesion(mjtBool value) {
    ptr_->flg_adhesion = value;
  }
  emscripten::val buffer() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbuffer, static_cast<uint8_t*>(ptr_->buffer)));
  }
  emscripten::val qpos0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nq, ptr_->qpos0));
  }
  emscripten::val qpos_spring() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nq, ptr_->qpos_spring));
  }
  emscripten::val body_parentid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_parentid));
  }
  emscripten::val body_rootid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_rootid));
  }
  emscripten::val body_weldid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_weldid));
  }
  emscripten::val body_mocapid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_mocapid));
  }
  emscripten::val body_jntnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_jntnum));
  }
  emscripten::val body_jntadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_jntadr));
  }
  emscripten::val body_dofnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_dofnum));
  }
  emscripten::val body_dofadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_dofadr));
  }
  emscripten::val body_treeid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_treeid));
  }
  emscripten::val body_geomnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_geomnum));
  }
  emscripten::val body_geomadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_geomadr));
  }
  emscripten::val body_simple() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_simple));
  }
  emscripten::val body_sameframe() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_sameframe));
  }
  emscripten::val body_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_pos));
  }
  emscripten::val body_quat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 4, ptr_->body_quat));
  }
  emscripten::val body_ipos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_ipos));
  }
  emscripten::val body_iquat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 4, ptr_->body_iquat));
  }
  emscripten::val body_mass() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_mass));
  }
  emscripten::val body_subtreemass() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_subtreemass));
  }
  emscripten::val body_inertia() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_inertia));
  }
  emscripten::val body_invweight0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 2, ptr_->body_invweight0));
  }
  emscripten::val body_gravcomp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_gravcomp));
  }
  emscripten::val body_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_margin));
  }
  emscripten::val body_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * ptr_->nuser_body, ptr_->body_user));
  }
  emscripten::val body_plugin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_plugin));
  }
  emscripten::val body_contype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_contype));
  }
  emscripten::val body_conaffinity() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_conaffinity));
  }
  emscripten::val body_bvhadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_bvhadr));
  }
  emscripten::val body_bvhnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_bvhnum));
  }
  emscripten::val bvh_depth() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh, ptr_->bvh_depth));
  }
  emscripten::val bvh_child() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh * 2, ptr_->bvh_child));
  }
  emscripten::val bvh_nodeid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh, ptr_->bvh_nodeid));
  }
  emscripten::val bvh_aabb() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbvhstatic * 6, ptr_->bvh_aabb));
  }
  emscripten::val oct_depth() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->noct, ptr_->oct_depth));
  }
  emscripten::val oct_child() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 8, ptr_->oct_child));
  }
  emscripten::val oct_aabb() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 6, ptr_->oct_aabb));
  }
  emscripten::val oct_coeff() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 8, ptr_->oct_coeff));
  }
  emscripten::val jnt_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_type));
  }
  emscripten::val jnt_qposadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_qposadr));
  }
  emscripten::val jnt_dofadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_dofadr));
  }
  emscripten::val jnt_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_bodyid));
  }
  emscripten::val jnt_actuatorid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actuatorid));
  }
  emscripten::val jnt_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_group));
  }
  emscripten::val jnt_limited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_limited));
  }
  emscripten::val jnt_actfrclimited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actfrclimited));
  }
  emscripten::val jnt_actgravcomp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actgravcomp));
  }
  emscripten::val jnt_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNREF, ptr_->jnt_solref));
  }
  emscripten::val jnt_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNIMP, ptr_->jnt_solimp));
  }
  emscripten::val jnt_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 3, ptr_->jnt_pos));
  }
  emscripten::val jnt_axis() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 3, ptr_->jnt_axis));
  }
  emscripten::val jnt_stiffness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_stiffness));
  }
  emscripten::val jnt_stiffnesspoly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNPOLY, ptr_->jnt_stiffnesspoly));
  }
  emscripten::val jnt_range() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 2, ptr_->jnt_range));
  }
  emscripten::val jnt_actfrcrange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 2, ptr_->jnt_actfrcrange));
  }
  emscripten::val jnt_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_margin));
  }
  emscripten::val jnt_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * ptr_->nuser_jnt, ptr_->jnt_user));
  }
  emscripten::val dof_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_bodyid));
  }
  emscripten::val dof_jntid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_jntid));
  }
  emscripten::val dof_parentid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_parentid));
  }
  emscripten::val dof_treeid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_treeid));
  }
  emscripten::val dof_Madr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_Madr));
  }
  emscripten::val dof_simplenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_simplenum));
  }
  emscripten::val dof_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNREF, ptr_->dof_solref));
  }
  emscripten::val dof_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNIMP, ptr_->dof_solimp));
  }
  emscripten::val dof_frictionloss() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_frictionloss));
  }
  emscripten::val dof_armature() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_armature));
  }
  emscripten::val dof_damping() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_damping));
  }
  emscripten::val dof_dampingpoly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNPOLY, ptr_->dof_dampingpoly));
  }
  emscripten::val dof_invweight0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_invweight0));
  }
  emscripten::val dof_M0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_M0));
  }
  emscripten::val dof_length() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_length));
  }
  emscripten::val tree_bodyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_bodyadr));
  }
  emscripten::val tree_bodynum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_bodynum));
  }
  emscripten::val tree_dofadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_dofadr));
  }
  emscripten::val tree_dofnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_dofnum));
  }
  emscripten::val tree_sleep_policy() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_sleep_policy));
  }
  emscripten::val geom_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_type));
  }
  emscripten::val geom_contype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_contype));
  }
  emscripten::val geom_conaffinity() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_conaffinity));
  }
  emscripten::val geom_condim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_condim));
  }
  emscripten::val geom_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_bodyid));
  }
  emscripten::val geom_dataid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_dataid));
  }
  emscripten::val geom_matid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_matid));
  }
  emscripten::val geom_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_group));
  }
  emscripten::val geom_priority() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_priority));
  }
  emscripten::val geom_plugin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_plugin));
  }
  emscripten::val geom_sameframe() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_sameframe));
  }
  emscripten::val geom_solmix() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_solmix));
  }
  emscripten::val geom_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNREF, ptr_->geom_solref));
  }
  emscripten::val geom_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNIMP, ptr_->geom_solimp));
  }
  emscripten::val geom_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_size));
  }
  emscripten::val geom_aabb() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 6, ptr_->geom_aabb));
  }
  emscripten::val geom_rbound() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_rbound));
  }
  emscripten::val geom_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_pos));
  }
  emscripten::val geom_quat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 4, ptr_->geom_quat));
  }
  emscripten::val geom_friction() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_friction));
  }
  emscripten::val geom_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_margin));
  }
  emscripten::val geom_gap() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_gap));
  }
  emscripten::val geom_surfacevel() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 6, ptr_->geom_surfacevel));
  }
  emscripten::val geom_adhesion() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_adhesion));
  }
  emscripten::val geom_fluid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNFLUID, ptr_->geom_fluid));
  }
  emscripten::val geom_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * ptr_->nuser_geom, ptr_->geom_user));
  }
  emscripten::val geom_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 4, ptr_->geom_rgba));
  }
  emscripten::val site_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_type));
  }
  emscripten::val site_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_bodyid));
  }
  emscripten::val site_matid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_matid));
  }
  emscripten::val site_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_group));
  }
  emscripten::val site_sameframe() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_sameframe));
  }
  emscripten::val site_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 3, ptr_->site_size));
  }
  emscripten::val site_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 3, ptr_->site_pos));
  }
  emscripten::val site_quat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 4, ptr_->site_quat));
  }
  emscripten::val site_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * ptr_->nuser_site, ptr_->site_user));
  }
  emscripten::val site_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 4, ptr_->site_rgba));
  }
  emscripten::val cam_mode() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_mode));
  }
  emscripten::val cam_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_bodyid));
  }
  emscripten::val cam_targetbodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_targetbodyid));
  }
  emscripten::val cam_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_pos));
  }
  emscripten::val cam_quat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 4, ptr_->cam_quat));
  }
  emscripten::val cam_poscom0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_poscom0));
  }
  emscripten::val cam_pos0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_pos0));
  }
  emscripten::val cam_mat0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 9, ptr_->cam_mat0));
  }
  emscripten::val cam_projection() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_projection));
  }
  emscripten::val cam_fovy() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_fovy));
  }
  emscripten::val cam_ipd() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_ipd));
  }
  emscripten::val cam_resolution() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 2, ptr_->cam_resolution));
  }
  emscripten::val cam_output() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_output));
  }
  emscripten::val cam_sensorsize() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 2, ptr_->cam_sensorsize));
  }
  emscripten::val cam_intrinsic() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 4, ptr_->cam_intrinsic));
  }
  emscripten::val cam_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * ptr_->nuser_cam, ptr_->cam_user));
  }
  emscripten::val light_mode() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_mode));
  }
  emscripten::val light_bodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_bodyid));
  }
  emscripten::val light_targetbodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_targetbodyid));
  }
  emscripten::val light_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_type));
  }
  emscripten::val light_texid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_texid));
  }
  emscripten::val light_castshadow() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_castshadow));
  }
  emscripten::val light_bulbradius() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_bulbradius));
  }
  emscripten::val light_intensity() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_intensity));
  }
  emscripten::val light_range() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_range));
  }
  emscripten::val light_active() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_active));
  }
  emscripten::val light_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_pos));
  }
  emscripten::val light_dir() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_dir));
  }
  emscripten::val light_poscom0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_poscom0));
  }
  emscripten::val light_pos0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_pos0));
  }
  emscripten::val light_dir0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_dir0));
  }
  emscripten::val light_attenuation() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_attenuation));
  }
  emscripten::val light_cutoff() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_cutoff));
  }
  emscripten::val light_softness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_softness));
  }
  emscripten::val light_exponent() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_exponent));
  }
  emscripten::val light_ambient() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_ambient));
  }
  emscripten::val light_diffuse() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_diffuse));
  }
  emscripten::val light_specular() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_specular));
  }
  emscripten::val flex_contype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_contype));
  }
  emscripten::val flex_conaffinity() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_conaffinity));
  }
  emscripten::val flex_condim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_condim));
  }
  emscripten::val flex_priority() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_priority));
  }
  emscripten::val flex_solmix() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_solmix));
  }
  emscripten::val flex_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * mjNREF, ptr_->flex_solref));
  }
  emscripten::val flex_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * mjNIMP, ptr_->flex_solimp));
  }
  emscripten::val flex_friction() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_friction));
  }
  emscripten::val flex_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_margin));
  }
  emscripten::val flex_gap() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_gap));
  }
  emscripten::val flex_internal() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_internal));
  }
  emscripten::val flex_selfcollide() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_selfcollide));
  }
  emscripten::val flex_activelayers() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_activelayers));
  }
  emscripten::val flex_passive() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_passive));
  }
  emscripten::val flex_dim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_dim));
  }
  emscripten::val flex_matid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_matid));
  }
  emscripten::val flex_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_group));
  }
  emscripten::val flex_interp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_interp));
  }
  emscripten::val flex_cellnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_cellnum));
  }
  emscripten::val flex_nodeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_nodeadr));
  }
  emscripten::val flex_nodenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_nodenum));
  }
  emscripten::val flex_vertadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_vertadr));
  }
  emscripten::val flex_vertnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_vertnum));
  }
  emscripten::val flex_edgeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgeadr));
  }
  emscripten::val flex_edgenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgenum));
  }
  emscripten::val flex_elemadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemadr));
  }
  emscripten::val flex_elemnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemnum));
  }
  emscripten::val flex_elemdataadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemdataadr));
  }
  emscripten::val flex_stiffnessadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_stiffnessadr));
  }
  emscripten::val flex_elemedgeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemedgeadr));
  }
  emscripten::val flex_bendingadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bendingadr));
  }
  emscripten::val flex_shellnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_shellnum));
  }
  emscripten::val flex_shelldataadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_shelldataadr));
  }
  emscripten::val flex_evpairadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_evpairadr));
  }
  emscripten::val flex_evpairnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_evpairnum));
  }
  emscripten::val flex_texcoordadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_texcoordadr));
  }
  emscripten::val flex_nodebodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode, ptr_->flex_nodebodyid));
  }
  emscripten::val flex_vertbodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertbodyid));
  }
  emscripten::val flex_vertedgeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertedgeadr));
  }
  emscripten::val flex_vertedgenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertedgenum));
  }
  emscripten::val flex_vertedge() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_vertedge));
  }
  emscripten::val flex_edge() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_edge));
  }
  emscripten::val flex_edgeflap() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_edgeflap));
  }
  emscripten::val flex_elem() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemdata, ptr_->flex_elem));
  }
  emscripten::val flex_elemtexcoord() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemdata, ptr_->flex_elemtexcoord));
  }
  emscripten::val flex_elemedge() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemedge, ptr_->flex_elemedge));
  }
  emscripten::val flex_elemlayer() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelem, ptr_->flex_elemlayer));
  }
  emscripten::val flex_shell() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexshelldata, ptr_->flex_shell));
  }
  emscripten::val flex_evpair() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexevpair * 2, ptr_->flex_evpair));
  }
  emscripten::val flex_vert() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 3, ptr_->flex_vert));
  }
  emscripten::val flex_vert0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 3, ptr_->flex_vert0));
  }
  emscripten::val flex_vertmetric() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 4, ptr_->flex_vertmetric));
  }
  emscripten::val flex_node() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode * 3, ptr_->flex_node));
  }
  emscripten::val flex_node0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode * 3, ptr_->flex_node0));
  }
  emscripten::val flexedge_length0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_length0));
  }
  emscripten::val flexedge_invweight0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_invweight0));
  }
  emscripten::val flex_radius() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_radius));
  }
  emscripten::val flex_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_size));
  }
  emscripten::val flex_stiffness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexstiffness, ptr_->flex_stiffness));
  }
  emscripten::val flex_bending() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexbending, ptr_->flex_bending));
  }
  emscripten::val efm0_dofid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_dofid));
  }
  emscripten::val efm0_L_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_L_rownnz));
  }
  emscripten::val efm0_L_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_L_rowadr));
  }
  emscripten::val efm0_L_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0L, ptr_->efm0_L_colind));
  }
  emscripten::val efm0_L() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0L, ptr_->efm0_L));
  }
  emscripten::val flex_damping() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_damping));
  }
  emscripten::val flex_edgestiffness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgestiffness));
  }
  emscripten::val flex_edgedamping() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgedamping));
  }
  emscripten::val flex_edgeequality() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgeequality));
  }
  emscripten::val flex_rigid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_rigid));
  }
  emscripten::val flexedge_rigid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_rigid));
  }
  emscripten::val flex_centered() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_centered));
  }
  emscripten::val flex_flatskin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_flatskin));
  }
  emscripten::val flex_bvhadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bvhadr));
  }
  emscripten::val flex_bvhnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bvhnum));
  }
  emscripten::val flexedge_J_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_J_rownnz));
  }
  emscripten::val flexedge_J_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_J_rowadr));
  }
  emscripten::val flexedge_J_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nJfe, ptr_->flexedge_J_colind));
  }
  emscripten::val flexvert_J_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 2, ptr_->flexvert_J_rownnz));
  }
  emscripten::val flexvert_J_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 2, ptr_->flexvert_J_rowadr));
  }
  emscripten::val flexvert_J_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nJfv * 2, ptr_->flexvert_J_colind));
  }
  emscripten::val flex_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 4, ptr_->flex_rgba));
  }
  emscripten::val flex_texcoord() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflextexcoord * 2, ptr_->flex_texcoord));
  }
  emscripten::val mesh_vertadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_vertadr));
  }
  emscripten::val mesh_vertnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_vertnum));
  }
  emscripten::val mesh_faceadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_faceadr));
  }
  emscripten::val mesh_facenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_facenum));
  }
  emscripten::val mesh_bvhadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_bvhadr));
  }
  emscripten::val mesh_bvhnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_bvhnum));
  }
  emscripten::val mesh_octadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_octadr));
  }
  emscripten::val mesh_octnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_octnum));
  }
  emscripten::val mesh_normaladr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_normaladr));
  }
  emscripten::val mesh_normalnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_normalnum));
  }
  emscripten::val mesh_texcoordadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_texcoordadr));
  }
  emscripten::val mesh_texcoordnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_texcoordnum));
  }
  emscripten::val mesh_graphadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_graphadr));
  }
  emscripten::val mesh_extrema() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 27, ptr_->mesh_extrema));
  }
  emscripten::val mesh_vert() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert * 3, ptr_->mesh_vert));
  }
  emscripten::val mesh_normal() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshnormal * 3, ptr_->mesh_normal));
  }
  emscripten::val mesh_texcoord() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshtexcoord * 2, ptr_->mesh_texcoord));
  }
  emscripten::val mesh_face() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_face));
  }
  emscripten::val mesh_facenormal() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_facenormal));
  }
  emscripten::val mesh_facetexcoord() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_facetexcoord));
  }
  emscripten::val mesh_graph() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshgraph, ptr_->mesh_graph));
  }
  emscripten::val mesh_scale() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 3, ptr_->mesh_scale));
  }
  emscripten::val mesh_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 3, ptr_->mesh_pos));
  }
  emscripten::val mesh_quat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 4, ptr_->mesh_quat));
  }
  emscripten::val mesh_pathadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_pathadr));
  }
  emscripten::val mesh_polynum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_polynum));
  }
  emscripten::val mesh_polyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_polyadr));
  }
  emscripten::val mesh_polynormal() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly * 3, ptr_->mesh_polynormal));
  }
  emscripten::val mesh_polyvertadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly, ptr_->mesh_polyvertadr));
  }
  emscripten::val mesh_polyvertnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly, ptr_->mesh_polyvertnum));
  }
  emscripten::val mesh_polyvert() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpolyvert, ptr_->mesh_polyvert));
  }
  emscripten::val mesh_polymapadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert, ptr_->mesh_polymapadr));
  }
  emscripten::val mesh_polymapnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert, ptr_->mesh_polymapnum));
  }
  emscripten::val mesh_polymap() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpolymap, ptr_->mesh_polymap));
  }
  emscripten::val skin_matid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_matid));
  }
  emscripten::val skin_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_group));
  }
  emscripten::val skin_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin * 4, ptr_->skin_rgba));
  }
  emscripten::val skin_inflate() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_inflate));
  }
  emscripten::val skin_vertadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_vertadr));
  }
  emscripten::val skin_vertnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_vertnum));
  }
  emscripten::val skin_texcoordadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_texcoordadr));
  }
  emscripten::val skin_faceadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_faceadr));
  }
  emscripten::val skin_facenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_facenum));
  }
  emscripten::val skin_boneadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_boneadr));
  }
  emscripten::val skin_bonenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_bonenum));
  }
  emscripten::val skin_vert() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinvert * 3, ptr_->skin_vert));
  }
  emscripten::val skin_texcoord() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskintexvert * 2, ptr_->skin_texcoord));
  }
  emscripten::val skin_face() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinface * 3, ptr_->skin_face));
  }
  emscripten::val skin_bonevertadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonevertadr));
  }
  emscripten::val skin_bonevertnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonevertnum));
  }
  emscripten::val skin_bonebindpos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone * 3, ptr_->skin_bonebindpos));
  }
  emscripten::val skin_bonebindquat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone * 4, ptr_->skin_bonebindquat));
  }
  emscripten::val skin_bonebodyid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonebodyid));
  }
  emscripten::val skin_bonevertid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbonevert, ptr_->skin_bonevertid));
  }
  emscripten::val skin_bonevertweight() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbonevert, ptr_->skin_bonevertweight));
  }
  emscripten::val skin_pathadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_pathadr));
  }
  emscripten::val hfield_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield * 4, ptr_->hfield_size));
  }
  emscripten::val hfield_nrow() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_nrow));
  }
  emscripten::val hfield_ncol() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_ncol));
  }
  emscripten::val hfield_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_adr));
  }
  emscripten::val hfield_data() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfielddata, ptr_->hfield_data));
  }
  emscripten::val hfield_pathadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_pathadr));
  }
  emscripten::val tex_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_type));
  }
  emscripten::val tex_colorspace() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_colorspace));
  }
  emscripten::val tex_height() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_height));
  }
  emscripten::val tex_width() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_width));
  }
  emscripten::val tex_nchannel() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_nchannel));
  }
  emscripten::val tex_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_adr));
  }
  emscripten::val tex_data() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntexdata, ptr_->tex_data));
  }
  emscripten::val tex_pathadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_pathadr));
  }
  emscripten::val mat_texid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * mjNTEXROLE, ptr_->mat_texid));
  }
  emscripten::val mat_texuniform() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_texuniform));
  }
  emscripten::val mat_texrepeat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * 2, ptr_->mat_texrepeat));
  }
  emscripten::val mat_emission() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_emission));
  }
  emscripten::val mat_specular() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_specular));
  }
  emscripten::val mat_shininess() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_shininess));
  }
  emscripten::val mat_reflectance() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_reflectance));
  }
  emscripten::val mat_metallic() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_metallic));
  }
  emscripten::val mat_roughness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_roughness));
  }
  emscripten::val mat_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * 4, ptr_->mat_rgba));
  }
  emscripten::val pair_dim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_dim));
  }
  emscripten::val pair_geom1() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_geom1));
  }
  emscripten::val pair_geom2() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_geom2));
  }
  emscripten::val pair_signature() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_signature));
  }
  emscripten::val pair_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNREF, ptr_->pair_solref));
  }
  emscripten::val pair_solreffriction() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNREF, ptr_->pair_solreffriction));
  }
  emscripten::val pair_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNIMP, ptr_->pair_solimp));
  }
  emscripten::val pair_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_margin));
  }
  emscripten::val pair_gap() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_gap));
  }
  emscripten::val pair_adhesion() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_adhesion));
  }
  emscripten::val pair_friction() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair * 5, ptr_->pair_friction));
  }
  emscripten::val exclude_signature() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nexclude, ptr_->exclude_signature));
  }
  emscripten::val eq_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_type));
  }
  emscripten::val eq_obj1id() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_obj1id));
  }
  emscripten::val eq_obj2id() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_obj2id));
  }
  emscripten::val eq_objtype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_objtype));
  }
  emscripten::val eq_active0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_active0));
  }
  emscripten::val eq_solref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNREF, ptr_->eq_solref));
  }
  emscripten::val eq_solimp() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNIMP, ptr_->eq_solimp));
  }
  emscripten::val eq_data() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNEQDATA, ptr_->eq_data));
  }
  emscripten::val tendon_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_adr));
  }
  emscripten::val tendon_num() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_num));
  }
  emscripten::val tendon_matid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_matid));
  }
  emscripten::val tendon_actuatorid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_actuatorid));
  }
  emscripten::val tendon_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_group));
  }
  emscripten::val tendon_treenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_treenum));
  }
  emscripten::val tendon_treeid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_treeid));
  }
  emscripten::val ten_J_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->ten_J_rownnz));
  }
  emscripten::val ten_J_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->ten_J_rowadr));
  }
  emscripten::val ten_J_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nJten, ptr_->ten_J_colind));
  }
  emscripten::val tendon_limited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_limited));
  }
  emscripten::val tendon_actfrclimited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_actfrclimited));
  }
  emscripten::val tendon_width() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_width));
  }
  emscripten::val tendon_solref_lim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNREF, ptr_->tendon_solref_lim));
  }
  emscripten::val tendon_solimp_lim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNIMP, ptr_->tendon_solimp_lim));
  }
  emscripten::val tendon_solref_fri() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNREF, ptr_->tendon_solref_fri));
  }
  emscripten::val tendon_solimp_fri() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNIMP, ptr_->tendon_solimp_fri));
  }
  emscripten::val tendon_range() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_range));
  }
  emscripten::val tendon_actfrcrange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_actfrcrange));
  }
  emscripten::val tendon_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_margin));
  }
  emscripten::val tendon_stiffness() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_stiffness));
  }
  emscripten::val tendon_stiffnesspoly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNPOLY, ptr_->tendon_stiffnesspoly));
  }
  emscripten::val tendon_damping() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_damping));
  }
  emscripten::val tendon_dampingpoly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNPOLY, ptr_->tendon_dampingpoly));
  }
  emscripten::val tendon_armature() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_armature));
  }
  emscripten::val tendon_frictionloss() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_frictionloss));
  }
  emscripten::val tendon_lengthspring() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_lengthspring));
  }
  emscripten::val tendon_length0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_length0));
  }
  emscripten::val tendon_invweight0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_invweight0));
  }
  emscripten::val tendon_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * ptr_->nuser_tendon, ptr_->tendon_user));
  }
  emscripten::val tendon_rgba() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 4, ptr_->tendon_rgba));
  }
  emscripten::val wrap_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_type));
  }
  emscripten::val wrap_objid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_objid));
  }
  emscripten::val wrap_prm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_prm));
  }
  emscripten::val actuator_trntype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_trntype));
  }
  emscripten::val actuator_dyntype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_dyntype));
  }
  emscripten::val actuator_gaintype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_gaintype));
  }
  emscripten::val actuator_biastype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_biastype));
  }
  emscripten::val actuator_ctrladr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_ctrladr));
  }
  emscripten::val actuator_ctrlnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_ctrlnum));
  }
  emscripten::val actuator_ctrlspec() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_ctrlspec));
  }
  emscripten::val actuator_outadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_outadr));
  }
  emscripten::val actuator_outnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_outnum));
  }
  emscripten::val actuator_actadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actadr));
  }
  emscripten::val actuator_actnum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actnum));
  }
  emscripten::val actuator_trnid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_trnid));
  }
  emscripten::val actuator_cranklength() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_cranklength));
  }
  emscripten::val actuator_dynprm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNDYN, ptr_->actuator_dynprm));
  }
  emscripten::val actuator_gainprm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNGAIN, ptr_->actuator_gainprm));
  }
  emscripten::val actuator_biasprm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNBIAS, ptr_->actuator_biasprm));
  }
  emscripten::val actuator_actlimited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actlimited));
  }
  emscripten::val actuator_actrange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_actrange));
  }
  emscripten::val actuator_actearly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actearly));
  }
  emscripten::val actuator_history() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_history));
  }
  emscripten::val actuator_historyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_historyadr));
  }
  emscripten::val actuator_delay() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_delay));
  }
  emscripten::val actuator_damping() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_damping));
  }
  emscripten::val actuator_dampingpoly() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNPOLY, ptr_->actuator_dampingpoly));
  }
  emscripten::val actuator_armature() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_armature));
  }
  emscripten::val actuator_group() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_group));
  }
  emscripten::val actuator_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * ptr_->nuser_actuator, ptr_->actuator_user));
  }
  emscripten::val actuator_plugin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_plugin));
  }
  emscripten::val actuator_forcelimited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_forcelimited));
  }
  emscripten::val actuator_forcerange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_forcerange));
  }
  emscripten::val actuator_ctrllimited() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nu, ptr_->actuator_ctrllimited));
  }
  emscripten::val actuator_ctrlrange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nu * 2, ptr_->actuator_ctrlrange));
  }
  emscripten::val actuator_gear() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nout * 6, ptr_->actuator_gear));
  }
  emscripten::val actuator_acc0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nout, ptr_->actuator_acc0));
  }
  emscripten::val actuator_length0() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nout, ptr_->actuator_length0));
  }
  emscripten::val actuator_lengthrange() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nout * 2, ptr_->actuator_lengthrange));
  }
  emscripten::val sensor_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_type));
  }
  emscripten::val sensor_datatype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_datatype));
  }
  emscripten::val sensor_needstage() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_needstage));
  }
  emscripten::val sensor_objtype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_objtype));
  }
  emscripten::val sensor_objid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_objid));
  }
  emscripten::val sensor_reftype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_reftype));
  }
  emscripten::val sensor_refid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_refid));
  }
  emscripten::val sensor_intprm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * mjNSENS, ptr_->sensor_intprm));
  }
  emscripten::val sensor_dim() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_dim));
  }
  emscripten::val sensor_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_adr));
  }
  emscripten::val sensor_cutoff() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_cutoff));
  }
  emscripten::val sensor_noise() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_noise));
  }
  emscripten::val sensor_history() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * 2, ptr_->sensor_history));
  }
  emscripten::val sensor_historyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_historyadr));
  }
  emscripten::val sensor_delay() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_delay));
  }
  emscripten::val sensor_interval() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * 2, ptr_->sensor_interval));
  }
  emscripten::val sensor_user() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * ptr_->nuser_sensor, ptr_->sensor_user));
  }
  emscripten::val sensor_plugin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_plugin));
  }
  emscripten::val plugin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin));
  }
  emscripten::val plugin_stateadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_stateadr));
  }
  emscripten::val plugin_statenum() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_statenum));
  }
  emscripten::val plugin_attr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npluginattr, ptr_->plugin_attr));
  }
  emscripten::val plugin_attradr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_attradr));
  }
  emscripten::val numeric_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->numeric_adr));
  }
  emscripten::val numeric_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->numeric_size));
  }
  emscripten::val numeric_data() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnumericdata, ptr_->numeric_data));
  }
  emscripten::val text_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->text_adr));
  }
  emscripten::val text_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->text_size));
  }
  emscripten::val text_data() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntextdata, ptr_->text_data));
  }
  emscripten::val tuple_adr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->tuple_adr));
  }
  emscripten::val tuple_size() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->tuple_size));
  }
  emscripten::val tuple_objtype() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objtype));
  }
  emscripten::val tuple_objid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objid));
  }
  emscripten::val tuple_objprm() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objprm));
  }
  emscripten::val key_time() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey, ptr_->key_time));
  }
  emscripten::val key_qpos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nq, ptr_->key_qpos));
  }
  emscripten::val key_qvel() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nv, ptr_->key_qvel));
  }
  emscripten::val key_act() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->na, ptr_->key_act));
  }
  emscripten::val key_mpos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nmocap*3, ptr_->key_mpos));
  }
  emscripten::val key_mquat() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nmocap*4, ptr_->key_mquat));
  }
  emscripten::val key_ctrl() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nu, ptr_->key_ctrl));
  }
  emscripten::val name_bodyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->name_bodyadr));
  }
  emscripten::val name_jntadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->name_jntadr));
  }
  emscripten::val name_geomadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->name_geomadr));
  }
  emscripten::val name_siteadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->name_siteadr));
  }
  emscripten::val name_camadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->name_camadr));
  }
  emscripten::val name_lightadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->name_lightadr));
  }
  emscripten::val name_flexadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->name_flexadr));
  }
  emscripten::val name_meshadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->name_meshadr));
  }
  emscripten::val name_skinadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->name_skinadr));
  }
  emscripten::val name_hfieldadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->name_hfieldadr));
  }
  emscripten::val name_texadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->name_texadr));
  }
  emscripten::val name_matadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->name_matadr));
  }
  emscripten::val name_pairadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->name_pairadr));
  }
  emscripten::val name_excludeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nexclude, ptr_->name_excludeadr));
  }
  emscripten::val name_eqadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->name_eqadr));
  }
  emscripten::val name_tendonadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->name_tendonadr));
  }
  emscripten::val name_actuatoradr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->name_actuatoradr));
  }
  emscripten::val name_sensoradr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->name_sensoradr));
  }
  emscripten::val name_numericadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->name_numericadr));
  }
  emscripten::val name_textadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->name_textadr));
  }
  emscripten::val name_tupleadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->name_tupleadr));
  }
  emscripten::val name_keyadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nkey, ptr_->name_keyadr));
  }
  emscripten::val name_pluginadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->name_pluginadr));
  }
  emscripten::val names() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnames, ptr_->names));
  }
  emscripten::val names_map() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nnames_map, ptr_->names_map));
  }
  emscripten::val paths() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->npaths, ptr_->paths));
  }
  emscripten::val B_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->B_rownnz));
  }
  emscripten::val B_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->B_rowadr));
  }
  emscripten::val B_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nB, ptr_->B_colind));
  }
  emscripten::val M_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->M_rownnz));
  }
  emscripten::val M_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->M_rowadr));
  }
  emscripten::val M_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->M_colind));
  }
  emscripten::val mapM2M() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->mapM2M));
  }
  emscripten::val D_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_rownnz));
  }
  emscripten::val D_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_rowadr));
  }
  emscripten::val D_diag() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_diag));
  }
  emscripten::val D_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nD, ptr_->D_colind));
  }
  emscripten::val mapM2D() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nD, ptr_->mapM2D));
  }
  emscripten::val mapD2M() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->mapD2M));
  }
  uint64_t signature() const {
    return ptr_->signature;
  }
  void set_signature(uint64_t value) {
    ptr_->signature = value;
  }
  // Generates functions to return accessor classes.
  #define X_ACCESSOR(NAME, Name, OBJTYPE, accessor_name, nfield)               \
    MjModel##Name##Accessor accessor_name(const NumberOrString& val) const {   \
      if (val.isString()) {                                                    \
        int id = mj_name2id(ptr_, OBJTYPE, val.as<std::string>().c_str());     \
        if (id == -1) {                                                        \
          mju_error("%s", KeyErrorMessage(ptr_, OBJTYPE, ptr_->nfield, val.as<std::string>(), #accessor_name).c_str());  \
        }                                                                      \
        return MjModel##Name##Accessor(ptr_, id);                              \
      } else if (val.isNumber()) {                                             \
        int id = val.as<int>();                                                \
        if (id < 0 || id >= ptr_->nfield) {                                    \
          mju_error("%s", IndexErrorMessage(id, ptr_->nfield, #accessor_name).c_str());  \
        }                                                                      \
        return MjModel##Name##Accessor(ptr_, id);                              \
      } else {                                                                 \
        mju_error(#accessor_name "() argument must be a string or number");    \
        return MjModel##Name##Accessor(nullptr, 0);                            \
      }                                                                        \
    }

    MJMODEL_ACCESSORS
  #undef X_ACCESSOR

 private:
  mjModel* ptr_;

 public:
  MjOption opt;
  MjVisual vis;
  MjStatistic stat;
};

struct MjSpec {
  ~MjSpec();
  MjSpec();
  explicit MjSpec(mjSpec *ptr);
  MjSpec(const MjSpec &);
  MjSpec &operator=(const MjSpec &);
  std::unique_ptr<MjSpec> copy();
  mjSpec* get() const;
  void set(mjSpec* ptr);
  emscripten::val timer() const;
  mjString modelname() const {
    return (ptr_ && ptr_->modelname) ? *(ptr_->modelname) : "";
  }
  void set_modelname(const mjString& value) {
    if (ptr_ && ptr_->modelname) {
      *(ptr_->modelname) = value;
    }
  }
  mjtBool strippath() const {
    return ptr_->strippath;
  }
  void set_strippath(mjtBool value) {
    ptr_->strippath = value;
  }
  int memory() const {
    return static_cast<int>(ptr_->memory);
  }
  void set_memory(int value) {
    ptr_->memory = static_cast<mjtSize>(value);
  }
  int nemax() const {
    return ptr_->nemax;
  }
  void set_nemax(int value) {
    ptr_->nemax = value;
  }
  int nuserdata() const {
    return ptr_->nuserdata;
  }
  void set_nuserdata(int value) {
    ptr_->nuserdata = value;
  }
  int nuser_body() const {
    return ptr_->nuser_body;
  }
  void set_nuser_body(int value) {
    ptr_->nuser_body = value;
  }
  int nuser_jnt() const {
    return ptr_->nuser_jnt;
  }
  void set_nuser_jnt(int value) {
    ptr_->nuser_jnt = value;
  }
  int nuser_geom() const {
    return ptr_->nuser_geom;
  }
  void set_nuser_geom(int value) {
    ptr_->nuser_geom = value;
  }
  int nuser_site() const {
    return ptr_->nuser_site;
  }
  void set_nuser_site(int value) {
    ptr_->nuser_site = value;
  }
  int nuser_cam() const {
    return ptr_->nuser_cam;
  }
  void set_nuser_cam(int value) {
    ptr_->nuser_cam = value;
  }
  int nuser_tendon() const {
    return ptr_->nuser_tendon;
  }
  void set_nuser_tendon(int value) {
    ptr_->nuser_tendon = value;
  }
  int nuser_actuator() const {
    return ptr_->nuser_actuator;
  }
  void set_nuser_actuator(int value) {
    ptr_->nuser_actuator = value;
  }
  int nuser_sensor() const {
    return ptr_->nuser_sensor;
  }
  void set_nuser_sensor(int value) {
    ptr_->nuser_sensor = value;
  }
  int nkey() const {
    return ptr_->nkey;
  }
  void set_nkey(int value) {
    ptr_->nkey = value;
  }
  int njmax() const {
    return ptr_->njmax;
  }
  void set_njmax(int value) {
    ptr_->njmax = value;
  }
  int nconmax() const {
    return ptr_->nconmax;
  }
  void set_nconmax(int value) {
    ptr_->nconmax = value;
  }
  int nstack() const {
    return static_cast<int>(ptr_->nstack);
  }
  void set_nstack(int value) {
    ptr_->nstack = static_cast<mjtSize>(value);
  }
  mjString comment() const {
    return (ptr_ && ptr_->comment) ? *(ptr_->comment) : "";
  }
  void set_comment(const mjString& value) {
    if (ptr_ && ptr_->comment) {
      *(ptr_->comment) = value;
    }
  }
  mjString modelfiledir() const {
    return (ptr_ && ptr_->modelfiledir) ? *(ptr_->modelfiledir) : "";
  }
  void set_modelfiledir(const mjString& value) {
    if (ptr_ && ptr_->modelfiledir) {
      *(ptr_->modelfiledir) = value;
    }
  }
  mjtBool hasImplicitPluginElem() const {
    return ptr_->hasImplicitPluginElem;
  }
  void set_hasImplicitPluginElem(mjtBool value) {
    ptr_->hasImplicitPluginElem = value;
  }

 private:
  mjSpec* ptr_;
  bool owned_ = false;

 public:
  MjsElement element;
  MjsCompiler compiler;
  MjOption option;
  MjVisual visual;
  MjStatistic stat;
  MjsAuthored authored;
};

struct MjsActuator {
  explicit MjsActuator(mjsActuator *ptr);
  mjsActuator* get() const;
  void set(mjsActuator* ptr);
  mjtGain gaintype() const {
    return ptr_->gaintype;
  }
  void set_gaintype(mjtGain value) {
    ptr_->gaintype = value;
  }
  emscripten::val gainprm() const {
    return emscripten::val(emscripten::typed_memory_view(10, ptr_->gainprm));
  }
  mjtBias biastype() const {
    return ptr_->biastype;
  }
  void set_biastype(mjtBias value) {
    ptr_->biastype = value;
  }
  emscripten::val biasprm() const {
    return emscripten::val(emscripten::typed_memory_view(10, ptr_->biasprm));
  }
  mjtDyn dyntype() const {
    return ptr_->dyntype;
  }
  void set_dyntype(mjtDyn value) {
    ptr_->dyntype = value;
  }
  emscripten::val dynprm() const {
    return emscripten::val(emscripten::typed_memory_view(10, ptr_->dynprm));
  }
  int actdim() const {
    return ptr_->actdim;
  }
  void set_actdim(int value) {
    ptr_->actdim = value;
  }
  int ctrlspec() const {
    return ptr_->ctrlspec;
  }
  void set_ctrlspec(int value) {
    ptr_->ctrlspec = value;
  }
  emscripten::val velrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->velrange));
  }
  emscripten::val ffrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->ffrange));
  }
  mjtBool actearly() const {
    return ptr_->actearly;
  }
  void set_actearly(mjtBool value) {
    ptr_->actearly = value;
  }
  mjtTrn trntype() const {
    return ptr_->trntype;
  }
  void set_trntype(mjtTrn value) {
    ptr_->trntype = value;
  }
  emscripten::val gear() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->gear));
  }
  mjString target() const {
    return (ptr_ && ptr_->target) ? *(ptr_->target) : "";
  }
  void set_target(const mjString& value) {
    if (ptr_ && ptr_->target) {
      *(ptr_->target) = value;
    }
  }
  mjString refsite() const {
    return (ptr_ && ptr_->refsite) ? *(ptr_->refsite) : "";
  }
  void set_refsite(const mjString& value) {
    if (ptr_ && ptr_->refsite) {
      *(ptr_->refsite) = value;
    }
  }
  mjString slidersite() const {
    return (ptr_ && ptr_->slidersite) ? *(ptr_->slidersite) : "";
  }
  void set_slidersite(const mjString& value) {
    if (ptr_ && ptr_->slidersite) {
      *(ptr_->slidersite) = value;
    }
  }
  double cranklength() const {
    return ptr_->cranklength;
  }
  void set_cranklength(double value) {
    ptr_->cranklength = value;
  }
  emscripten::val lengthrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->lengthrange));
  }
  double inheritrange() const {
    return ptr_->inheritrange;
  }
  void set_inheritrange(double value) {
    ptr_->inheritrange = value;
  }
  emscripten::val damping() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
  }
  double armature() const {
    return ptr_->armature;
  }
  void set_armature(double value) {
    ptr_->armature = value;
  }
  mjtLimited ctrllimited() const {
    return ptr_->ctrllimited;
  }
  void set_ctrllimited(mjtLimited value) {
    ptr_->ctrllimited = value;
  }
  emscripten::val ctrlrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->ctrlrange));
  }
  mjtLimited forcelimited() const {
    return ptr_->forcelimited;
  }
  void set_forcelimited(mjtLimited value) {
    ptr_->forcelimited = value;
  }
  emscripten::val forcerange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->forcerange));
  }
  mjtLimited actlimited() const {
    return ptr_->actlimited;
  }
  void set_actlimited(mjtLimited value) {
    ptr_->actlimited = value;
  }
  emscripten::val actrange() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->actrange));
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  int nsample() const {
    return ptr_->nsample;
  }
  void set_nsample(int value) {
    ptr_->nsample = value;
  }
  int interp() const {
    return ptr_->interp;
  }
  void set_interp(int value) {
    ptr_->interp = value;
  }
  double delay() const {
    return ptr_->delay;
  }
  void set_delay(double value) {
    ptr_->delay = value;
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsActuator* ptr_;

 public:
  MjsElement element;
  MjsPlugin plugin;
};

struct MjsBody {
  explicit MjsBody(mjsBody *ptr);
  mjsBody* get() const;
  void set(mjsBody* ptr);
  mjString childclass() const {
    return (ptr_ && ptr_->childclass) ? *(ptr_->childclass) : "";
  }
  void set_childclass(const mjString& value) {
    if (ptr_ && ptr_->childclass) {
      *(ptr_->childclass) = value;
    }
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val quat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
  }
  double mass() const {
    return ptr_->mass;
  }
  void set_mass(double value) {
    ptr_->mass = value;
  }
  emscripten::val ipos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->ipos));
  }
  emscripten::val iquat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->iquat));
  }
  emscripten::val inertia() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->inertia));
  }
  emscripten::val fullinertia() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->fullinertia));
  }
  mjtBool mocap() const {
    return ptr_->mocap;
  }
  void set_mocap(mjtBool value) {
    ptr_->mocap = value;
  }
  double gravcomp() const {
    return ptr_->gravcomp;
  }
  void set_gravcomp(double value) {
    ptr_->gravcomp = value;
  }
  mjtSleepPolicy sleep() const {
    return ptr_->sleep;
  }
  void set_sleep(mjtSleepPolicy value) {
    ptr_->sleep = value;
  }
  mjtByte simple() const {
    return ptr_->simple;
  }
  void set_simple(mjtByte value) {
    ptr_->simple = value;
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjtBool explicitinertial() const {
    return ptr_->explicitinertial;
  }
  void set_explicitinertial(mjtBool value) {
    ptr_->explicitinertial = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsBody* ptr_;

 public:
  MjsElement element;
  MjsOrientation alt;
  MjsOrientation ialt;
  MjsPlugin plugin;
};

struct MjsGeom {
  explicit MjsGeom(mjsGeom *ptr);
  mjsGeom* get() const;
  void set(mjsGeom* ptr);
  mjtGeom type() const {
    return ptr_->type;
  }
  void set_type(mjtGeom value) {
    ptr_->type = value;
  }
  emscripten::val pos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
  }
  emscripten::val quat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
  }
  emscripten::val fromto() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->fromto));
  }
  emscripten::val size() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
  }
  int contype() const {
    return ptr_->contype;
  }
  void set_contype(int value) {
    ptr_->contype = value;
  }
  int conaffinity() const {
    return ptr_->conaffinity;
  }
  void set_conaffinity(int value) {
    ptr_->conaffinity = value;
  }
  int condim() const {
    return ptr_->condim;
  }
  void set_condim(int value) {
    ptr_->condim = value;
  }
  int priority() const {
    return ptr_->priority;
  }
  void set_priority(int value) {
    ptr_->priority = value;
  }
  emscripten::val friction() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->friction));
  }
  double solmix() const {
    return ptr_->solmix;
  }
  void set_solmix(double value) {
    ptr_->solmix = value;
  }
  emscripten::val solref() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
  }
  emscripten::val solimp() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
  }
  double margin() const {
    return ptr_->margin;
  }
  void set_margin(double value) {
    ptr_->margin = value;
  }
  double gap() const {
    return ptr_->gap;
  }
  void set_gap(double value) {
    ptr_->gap = value;
  }
  emscripten::val surfacevel() const {
    return emscripten::val(emscripten::typed_memory_view(6, ptr_->surfacevel));
  }
  double adhesion() const {
    return ptr_->adhesion;
  }
  void set_adhesion(double value) {
    ptr_->adhesion = value;
  }
  double mass() const {
    return ptr_->mass;
  }
  void set_mass(double value) {
    ptr_->mass = value;
  }
  double density() const {
    return ptr_->density;
  }
  void set_density(double value) {
    ptr_->density = value;
  }
  mjtGeomInertia typeinertia() const {
    return ptr_->typeinertia;
  }
  void set_typeinertia(mjtGeomInertia value) {
    ptr_->typeinertia = value;
  }
  mjtNum fluid_ellipsoid() const {
    return ptr_->fluid_ellipsoid;
  }
  void set_fluid_ellipsoid(mjtNum value) {
    ptr_->fluid_ellipsoid = value;
  }
  emscripten::val fluid_coefs() const {
    return emscripten::val(emscripten::typed_memory_view(5, ptr_->fluid_coefs));
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  emscripten::val rgba() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
  }
  int group() const {
    return ptr_->group;
  }
  void set_group(int value) {
    ptr_->group = value;
  }
  mjString hfieldname() const {
    return (ptr_ && ptr_->hfieldname) ? *(ptr_->hfieldname) : "";
  }
  void set_hfieldname(const mjString& value) {
    if (ptr_ && ptr_->hfieldname) {
      *(ptr_->hfieldname) = value;
    }
  }
  mjString meshname() const {
    return (ptr_ && ptr_->meshname) ? *(ptr_->meshname) : "";
  }
  void set_meshname(const mjString& value) {
    if (ptr_ && ptr_->meshname) {
      *(ptr_->meshname) = value;
    }
  }
  double fitscale() const {
    return ptr_->fitscale;
  }
  void set_fitscale(double value) {
    ptr_->fitscale = value;
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsGeom* ptr_;

 public:
  MjsElement element;
  MjsOrientation alt;
  MjsPlugin plugin;
};

struct MjsMesh {
  explicit MjsMesh(mjsMesh *ptr);
  mjsMesh* get() const;
  void set(mjsMesh* ptr);
  mjString content_type() const {
    return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
  }
  void set_content_type(const mjString& value) {
    if (ptr_ && ptr_->content_type) {
      *(ptr_->content_type) = value;
    }
  }
  mjString file() const {
    return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
  }
  void set_file(const mjString& value) {
    if (ptr_ && ptr_->file) {
      *(ptr_->file) = value;
    }
  }
  emscripten::val refpos() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->refpos));
  }
  emscripten::val refquat() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->refquat));
  }
  emscripten::val scale() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->scale));
  }
  mjtMeshInertia inertia() const {
    return ptr_->inertia;
  }
  void set_inertia(mjtMeshInertia value) {
    ptr_->inertia = value;
  }
  mjtBool smoothnormal() const {
    return ptr_->smoothnormal;
  }
  void set_smoothnormal(mjtBool value) {
    ptr_->smoothnormal = value;
  }
  mjtBool needsdf() const {
    return ptr_->needsdf;
  }
  void set_needsdf(mjtBool value) {
    ptr_->needsdf = value;
  }
  int maxhullvert() const {
    return ptr_->maxhullvert;
  }
  void set_maxhullvert(int value) {
    ptr_->maxhullvert = value;
  }
  mjFloatVec &uservert() const {
    return *(ptr_->uservert);
  }
  mjFloatVec &usernormal() const {
    return *(ptr_->usernormal);
  }
  mjFloatVec &usertexcoord() const {
    return *(ptr_->usertexcoord);
  }
  mjIntVec &userface() const {
    return *(ptr_->userface);
  }
  mjIntVec &userfacenormal() const {
    return *(ptr_->userfacenormal);
  }
  mjIntVec &userfacetexcoord() const {
    return *(ptr_->userfacetexcoord);
  }
  mjString material() const {
    return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
  }
  void set_material(const mjString& value) {
    if (ptr_ && ptr_->material) {
      *(ptr_->material) = value;
    }
  }
  int octree_maxdepth() const {
    return ptr_->octree_maxdepth;
  }
  void set_octree_maxdepth(int value) {
    ptr_->octree_maxdepth = value;
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsMesh* ptr_;

 public:
  MjsElement element;
  MjsPlugin plugin;
};

struct MjsSensor {
  explicit MjsSensor(mjsSensor *ptr);
  mjsSensor* get() const;
  void set(mjsSensor* ptr);
  mjtSensor type() const {
    return ptr_->type;
  }
  void set_type(mjtSensor value) {
    ptr_->type = value;
  }
  mjtObj objtype() const {
    return ptr_->objtype;
  }
  void set_objtype(mjtObj value) {
    ptr_->objtype = value;
  }
  mjString objname() const {
    return (ptr_ && ptr_->objname) ? *(ptr_->objname) : "";
  }
  void set_objname(const mjString& value) {
    if (ptr_ && ptr_->objname) {
      *(ptr_->objname) = value;
    }
  }
  mjtObj reftype() const {
    return ptr_->reftype;
  }
  void set_reftype(mjtObj value) {
    ptr_->reftype = value;
  }
  mjString refname() const {
    return (ptr_ && ptr_->refname) ? *(ptr_->refname) : "";
  }
  void set_refname(const mjString& value) {
    if (ptr_ && ptr_->refname) {
      *(ptr_->refname) = value;
    }
  }
  emscripten::val intprm() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->intprm));
  }
  mjtDataType datatype() const {
    return ptr_->datatype;
  }
  void set_datatype(mjtDataType value) {
    ptr_->datatype = value;
  }
  mjtStage needstage() const {
    return ptr_->needstage;
  }
  void set_needstage(mjtStage value) {
    ptr_->needstage = value;
  }
  int dim() const {
    return ptr_->dim;
  }
  void set_dim(int value) {
    ptr_->dim = value;
  }
  double cutoff() const {
    return ptr_->cutoff;
  }
  void set_cutoff(double value) {
    ptr_->cutoff = value;
  }
  double noise() const {
    return ptr_->noise;
  }
  void set_noise(double value) {
    ptr_->noise = value;
  }
  int nsample() const {
    return ptr_->nsample;
  }
  void set_nsample(int value) {
    ptr_->nsample = value;
  }
  int interp() const {
    return ptr_->interp;
  }
  void set_interp(int value) {
    ptr_->interp = value;
  }
  double delay() const {
    return ptr_->delay;
  }
  void set_delay(double value) {
    ptr_->delay = value;
  }
  emscripten::val interval() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->interval));
  }
  mjDoubleVec &userdata() const {
    return *(ptr_->userdata);
  }
  mjString info() const {
    return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
  }
  void set_info(const mjString& value) {
    if (ptr_ && ptr_->info) {
      *(ptr_->info) = value;
    }
  }

 private:
  mjsSensor* ptr_;

 public:
  MjsElement element;
  MjsPlugin plugin;
};

struct MjData {
  ~MjData();
  MjData(MjModel *m);
  explicit MjData(const MjModel &, const MjData &);
  std::vector<MjContact> contact() const;
  std::unique_ptr<MjData> copy();
  mjData* get() const;
  void set(mjData* ptr);
  int narena() const {
    return static_cast<int>(ptr_->narena);
  }
  void set_narena(int value) {
    ptr_->narena = static_cast<mjtSize>(value);
  }
  int nbuffer() const {
    return static_cast<int>(ptr_->nbuffer);
  }
  void set_nbuffer(int value) {
    ptr_->nbuffer = static_cast<mjtSize>(value);
  }
  int nplugin() const {
    return ptr_->nplugin;
  }
  void set_nplugin(int value) {
    ptr_->nplugin = value;
  }
  size_t pstack() const {
    return ptr_->pstack;
  }
  void set_pstack(size_t value) {
    ptr_->pstack = value;
  }
  size_t pbase() const {
    return ptr_->pbase;
  }
  void set_pbase(size_t value) {
    ptr_->pbase = value;
  }
  size_t parena() const {
    return ptr_->parena;
  }
  void set_parena(size_t value) {
    ptr_->parena = value;
  }
  uintptr_t threadpool() const {
    return ptr_->threadpool;
  }
  void set_threadpool(uintptr_t value) {
    ptr_->threadpool = value;
  }
  mjtBool threadlock() const {
    return ptr_->threadlock;
  }
  void set_threadlock(mjtBool value) {
    ptr_->threadlock = value;
  }
  int maxuse_stack() const {
    return static_cast<int>(ptr_->maxuse_stack);
  }
  void set_maxuse_stack(int value) {
    ptr_->maxuse_stack = static_cast<mjtSize>(value);
  }
  int maxuse_arena() const {
    return static_cast<int>(ptr_->maxuse_arena);
  }
  void set_maxuse_arena(int value) {
    ptr_->maxuse_arena = static_cast<mjtSize>(value);
  }
  int maxuse_con() const {
    return ptr_->maxuse_con;
  }
  void set_maxuse_con(int value) {
    ptr_->maxuse_con = value;
  }
  int maxuse_efc() const {
    return ptr_->maxuse_efc;
  }
  void set_maxuse_efc(int value) {
    ptr_->maxuse_efc = value;
  }
  emscripten::val solver_niter() const {
    return emscripten::val(emscripten::typed_memory_view(20, ptr_->solver_niter));
  }
  emscripten::val solver_nnz() const {
    return emscripten::val(emscripten::typed_memory_view(20, ptr_->solver_nnz));
  }
  emscripten::val solver_fwdinv() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->solver_fwdinv));
  }
  int ncon() const {
    return ptr_->ncon;
  }
  void set_ncon(int value) {
    ptr_->ncon = value;
  }
  int ne() const {
    return ptr_->ne;
  }
  void set_ne(int value) {
    ptr_->ne = value;
  }
  int nf() const {
    return ptr_->nf;
  }
  void set_nf(int value) {
    ptr_->nf = value;
  }
  int nl() const {
    return ptr_->nl;
  }
  void set_nl(int value) {
    ptr_->nl = value;
  }
  int nefc() const {
    return ptr_->nefc;
  }
  void set_nefc(int value) {
    ptr_->nefc = value;
  }
  int nJ() const {
    return ptr_->nJ;
  }
  void set_nJ(int value) {
    ptr_->nJ = value;
  }
  int efm_active() const {
    return ptr_->efm_active;
  }
  void set_efm_active(int value) {
    ptr_->efm_active = value;
  }
  int nefmK() const {
    return ptr_->nefmK;
  }
  void set_nefmK(int value) {
    ptr_->nefmK = value;
  }
  int nefmdof() const {
    return ptr_->nefmdof;
  }
  void set_nefmdof(int value) {
    ptr_->nefmdof = value;
  }
  int nefmL() const {
    return ptr_->nefmL;
  }
  void set_nefmL(int value) {
    ptr_->nefmL = value;
  }
  int nY() const {
    return ptr_->nY;
  }
  void set_nY(int value) {
    ptr_->nY = value;
  }
  int nA() const {
    return ptr_->nA;
  }
  void set_nA(int value) {
    ptr_->nA = value;
  }
  int nisland() const {
    return ptr_->nisland;
  }
  void set_nisland(int value) {
    ptr_->nisland = value;
  }
  int nidof() const {
    return ptr_->nidof;
  }
  void set_nidof(int value) {
    ptr_->nidof = value;
  }
  int ntree_awake() const {
    return ptr_->ntree_awake;
  }
  void set_ntree_awake(int value) {
    ptr_->ntree_awake = value;
  }
  int nbody_awake() const {
    return ptr_->nbody_awake;
  }
  void set_nbody_awake(int value) {
    ptr_->nbody_awake = value;
  }
  int nparent_awake() const {
    return ptr_->nparent_awake;
  }
  void set_nparent_awake(int value) {
    ptr_->nparent_awake = value;
  }
  int nv_awake() const {
    return ptr_->nv_awake;
  }
  void set_nv_awake(int value) {
    ptr_->nv_awake = value;
  }
  mjtBool flg_energypos() const {
    return ptr_->flg_energypos;
  }
  void set_flg_energypos(mjtBool value) {
    ptr_->flg_energypos = value;
  }
  mjtBool flg_energyvel() const {
    return ptr_->flg_energyvel;
  }
  void set_flg_energyvel(mjtBool value) {
    ptr_->flg_energyvel = value;
  }
  mjtBool flg_subtreevel() const {
    return ptr_->flg_subtreevel;
  }
  void set_flg_subtreevel(mjtBool value) {
    ptr_->flg_subtreevel = value;
  }
  mjtBool flg_rnepost() const {
    return ptr_->flg_rnepost;
  }
  void set_flg_rnepost(mjtBool value) {
    ptr_->flg_rnepost = value;
  }
  mjtNum time() const {
    return ptr_->time;
  }
  void set_time(mjtNum value) {
    ptr_->time = value;
  }
  emscripten::val energy() const {
    return emscripten::val(emscripten::typed_memory_view(2, ptr_->energy));
  }
  emscripten::val buffer() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbuffer, static_cast<uint8_t*>(ptr_->buffer)));
  }
  emscripten::val arena() const {
    return emscripten::val(emscripten::typed_memory_view(model->narena, static_cast<uint8_t*>(ptr_->arena)));
  }
  emscripten::val qpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nq, ptr_->qpos));
  }
  emscripten::val qvel() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qvel));
  }
  emscripten::val act() const {
    return emscripten::val(emscripten::typed_memory_view(model->na, ptr_->act));
  }
  emscripten::val history() const {
    return emscripten::val(emscripten::typed_memory_view(model->nhistory, ptr_->history));
  }
  emscripten::val qacc_warmstart() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc_warmstart));
  }
  emscripten::val plugin_state() const {
    return emscripten::val(emscripten::typed_memory_view(model->npluginstate, ptr_->plugin_state));
  }
  emscripten::val ctrl() const {
    return emscripten::val(emscripten::typed_memory_view(model->nu, ptr_->ctrl));
  }
  emscripten::val qfrc_applied() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_applied));
  }
  emscripten::val xfrc_applied() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->xfrc_applied));
  }
  emscripten::val eq_active() const {
    return emscripten::val(emscripten::typed_memory_view(model->neq, ptr_->eq_active));
  }
  emscripten::val mocap_pos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nmocap * 3, ptr_->mocap_pos));
  }
  emscripten::val mocap_quat() const {
    return emscripten::val(emscripten::typed_memory_view(model->nmocap * 4, ptr_->mocap_quat));
  }
  emscripten::val qacc() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc));
  }
  emscripten::val act_dot() const {
    return emscripten::val(emscripten::typed_memory_view(model->na, ptr_->act_dot));
  }
  emscripten::val userdata() const {
    return emscripten::val(emscripten::typed_memory_view(model->nuserdata, ptr_->userdata));
  }
  emscripten::val sensordata() const {
    return emscripten::val(emscripten::typed_memory_view(model->nsensordata, ptr_->sensordata));
  }
  emscripten::val tree_asleep() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_asleep));
  }
  emscripten::val plugin() const {
    return emscripten::val(emscripten::typed_memory_view(model->nplugin, ptr_->plugin));
  }
  emscripten::val plugin_data() const {
    return emscripten::val(emscripten::typed_memory_view(model->nplugin, ptr_->plugin_data));
  }
  emscripten::val xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->xpos));
  }
  emscripten::val xquat() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 4, ptr_->xquat));
  }
  emscripten::val xmat() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 9, ptr_->xmat));
  }
  emscripten::val xipos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->xipos));
  }
  emscripten::val ximat() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 9, ptr_->ximat));
  }
  emscripten::val xanchor() const {
    return emscripten::val(emscripten::typed_memory_view(model->njnt * 3, ptr_->xanchor));
  }
  emscripten::val xaxis() const {
    return emscripten::val(emscripten::typed_memory_view(model->njnt * 3, ptr_->xaxis));
  }
  emscripten::val geom_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->ngeom * 3, ptr_->geom_xpos));
  }
  emscripten::val geom_xmat() const {
    return emscripten::val(emscripten::typed_memory_view(model->ngeom * 9, ptr_->geom_xmat));
  }
  emscripten::val site_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nsite * 3, ptr_->site_xpos));
  }
  emscripten::val site_xmat() const {
    return emscripten::val(emscripten::typed_memory_view(model->nsite * 9, ptr_->site_xmat));
  }
  emscripten::val cam_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->ncam * 3, ptr_->cam_xpos));
  }
  emscripten::val cam_xmat() const {
    return emscripten::val(emscripten::typed_memory_view(model->ncam * 9, ptr_->cam_xmat));
  }
  emscripten::val light_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nlight * 3, ptr_->light_xpos));
  }
  emscripten::val light_xdir() const {
    return emscripten::val(emscripten::typed_memory_view(model->nlight * 3, ptr_->light_xdir));
  }
  emscripten::val subtree_com() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_com));
  }
  emscripten::val cdof() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv * 6, ptr_->cdof));
  }
  emscripten::val cinert() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 10, ptr_->cinert));
  }
  emscripten::val flexvert_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexvert * 3, ptr_->flexvert_xpos));
  }
  emscripten::val flexelem_aabb() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexelem * 6, ptr_->flexelem_aabb));
  }
  emscripten::val flexelem_krot() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexstiffness, ptr_->flexelem_krot));
  }
  emscripten::val flexedge_J() const {
    return emscripten::val(emscripten::typed_memory_view(model->nJfe, ptr_->flexedge_J));
  }
  emscripten::val flexedge_length() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexedge, ptr_->flexedge_length));
  }
  emscripten::val flexvert_J() const {
    return emscripten::val(emscripten::typed_memory_view(model->nJfv * 2, ptr_->flexvert_J));
  }
  emscripten::val flexvert_length() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexvert * 2, ptr_->flexvert_length));
  }
  emscripten::val bvh_aabb_dyn() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbvhdynamic * 6, ptr_->bvh_aabb_dyn));
  }
  emscripten::val ten_wrapadr() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_wrapadr));
  }
  emscripten::val ten_wrapnum() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_wrapnum));
  }
  emscripten::val ten_J() const {
    return emscripten::val(emscripten::typed_memory_view(model->nJten, ptr_->ten_J));
  }
  emscripten::val ten_length() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_length));
  }
  emscripten::val wrap_obj() const {
    return emscripten::val(emscripten::typed_memory_view(model->nwrap * 2, ptr_->wrap_obj));
  }
  emscripten::val wrap_xpos() const {
    return emscripten::val(emscripten::typed_memory_view(model->nwrap * 6, ptr_->wrap_xpos));
  }
  emscripten::val actuator_length() const {
    return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_length));
  }
  emscripten::val moment_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->moment_rownnz));
  }
  emscripten::val moment_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->moment_rowadr));
  }
  emscripten::val moment_colind() const {
    return emscripten::val(emscripten::typed_memory_view(model->nJmom, ptr_->moment_colind));
  }
  emscripten::val actuator_moment() const {
    return emscripten::val(emscripten::typed_memory_view(model->nJmom, ptr_->actuator_moment));
  }
  emscripten::val crb() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 10, ptr_->crb));
  }
  emscripten::val M() const {
    return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->M));
  }
  emscripten::val qLD() const {
    return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->qLD));
  }
  emscripten::val qLDiagInv() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qLDiagInv));
  }
  emscripten::val bvh_active() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbvh, ptr_->bvh_active));
  }
  emscripten::val tree_awake() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_awake));
  }
  emscripten::val body_awake() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->body_awake));
  }
  emscripten::val body_awake_ind() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->body_awake_ind));
  }
  emscripten::val parent_awake_ind() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->parent_awake_ind));
  }
  emscripten::val dof_awake_ind() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->dof_awake_ind));
  }
  emscripten::val flexedge_velocity() const {
    return emscripten::val(emscripten::typed_memory_view(model->nflexedge, ptr_->flexedge_velocity));
  }
  emscripten::val ten_velocity() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_velocity));
  }
  emscripten::val actuator_velocity() const {
    return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_velocity));
  }
  emscripten::val cvel() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cvel));
  }
  emscripten::val cdof_dot() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv * 6, ptr_->cdof_dot));
  }
  emscripten::val qfrc_bias() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_bias));
  }
  emscripten::val qfrc_spring() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_spring));
  }
  emscripten::val qfrc_damper() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_damper));
  }
  emscripten::val qfrc_gravcomp() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_gravcomp));
  }
  emscripten::val qfrc_fluid() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_fluid));
  }
  emscripten::val qfrc_adhesion() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_adhesion));
  }
  emscripten::val qfrc_passive() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_passive));
  }
  emscripten::val subtree_linvel() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_linvel));
  }
  emscripten::val subtree_angmom() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_angmom));
  }
  emscripten::val qH() const {
    return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->qH));
  }
  emscripten::val qHDiagInv() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qHDiagInv));
  }
  emscripten::val qDeriv() const {
    return emscripten::val(emscripten::typed_memory_view(model->nD, ptr_->qDeriv));
  }
  emscripten::val qLU() const {
    return emscripten::val(emscripten::typed_memory_view(model->nD, ptr_->qLU));
  }
  emscripten::val actuator_force() const {
    return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_force));
  }
  emscripten::val qfrc_actuator() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_actuator));
  }
  emscripten::val qfrc_smooth() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_smooth));
  }
  emscripten::val qacc_smooth() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc_smooth));
  }
  emscripten::val qfrc_constraint() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_constraint));
  }
  emscripten::val qfrc_inverse() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_inverse));
  }
  emscripten::val cacc() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cacc));
  }
  emscripten::val cfrc_int() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cfrc_int));
  }
  emscripten::val cfrc_ext() const {
    return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cfrc_ext));
  }
  // contact field is handled manually in template file struct declaration
  emscripten::val efc_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_type));
  }
  emscripten::val efc_id() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_id));
  }
  emscripten::val efc_J_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rownnz));
  }
  emscripten::val efc_J_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rowadr));
  }
  emscripten::val efc_J_rowsuper() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rowsuper));
  }
  emscripten::val efc_J_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nJ, ptr_->efc_J_colind));
  }
  emscripten::val efc_J() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nJ, ptr_->efc_J));
  }
  emscripten::val efc_pos() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_pos));
  }
  emscripten::val efc_margin() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_margin));
  }
  emscripten::val efc_frictionloss() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_frictionloss));
  }
  emscripten::val efc_diagA() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_diagA));
  }
  emscripten::val efc_KBIP() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc * 4, ptr_->efc_KBIP));
  }
  emscripten::val efc_D() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_D));
  }
  emscripten::val efc_R() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_R));
  }
  emscripten::val tendon_efcadr() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->tendon_efcadr));
  }
  emscripten::val tree_island() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_island));
  }
  emscripten::val island_ntree() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_ntree));
  }
  emscripten::val island_itreeadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_itreeadr));
  }
  emscripten::val map_itree2tree() const {
    return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->map_itree2tree));
  }
  emscripten::val dof_island() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->dof_island));
  }
  emscripten::val island_nv() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nv));
  }
  emscripten::val island_idofadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_idofadr));
  }
  emscripten::val island_dofadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_dofadr));
  }
  emscripten::val map_dof2idof() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->map_dof2idof));
  }
  emscripten::val map_idof2dof() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->map_idof2dof));
  }
  emscripten::val ifrc_smooth() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->ifrc_smooth));
  }
  emscripten::val iacc_smooth() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->iacc_smooth));
  }
  emscripten::val iacc() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->iacc));
  }
  emscripten::val efc_island() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_island));
  }
  emscripten::val island_ne() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_ne));
  }
  emscripten::val island_nf() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nf));
  }
  emscripten::val island_nefc() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nefc));
  }
  emscripten::val island_iefcadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_iefcadr));
  }
  emscripten::val map_efc2iefc() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->map_efc2iefc));
  }
  emscripten::val map_iefc2efc() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->map_iefc2efc));
  }
  emscripten::val iefc_type() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_type));
  }
  emscripten::val iefc_id() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_id));
  }
  emscripten::val iefc_frictionloss() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_frictionloss));
  }
  emscripten::val iefc_D() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_D));
  }
  emscripten::val iefc_R() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_R));
  }
  emscripten::val efc_Y_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_Y_rownnz));
  }
  emscripten::val efc_Y_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_Y_rowadr));
  }
  emscripten::val efc_Y_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nY, ptr_->efc_Y_colind));
  }
  emscripten::val efc_Y() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nY, ptr_->efc_Y));
  }
  emscripten::val efc_AR_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_AR_rownnz));
  }
  emscripten::val efc_AR_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_AR_rowadr));
  }
  emscripten::val efc_AR_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nA, ptr_->efc_AR_colind));
  }
  emscripten::val efc_AR() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nA, ptr_->efc_AR));
  }
  emscripten::val efc_vel() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_vel));
  }
  emscripten::val efc_aref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_aref));
  }
  emscripten::val efm_c() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_c));
  }
  emscripten::val efm_K_rownnz() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_K_rownnz));
  }
  emscripten::val efm_K_rowadr() const {
    return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_K_rowadr));
  }
  emscripten::val efm_K_colind() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefmK, ptr_->efm_K_colind));
  }
  emscripten::val efm_K_val() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefmK, ptr_->efm_K_val));
  }
  emscripten::val efm_dofid() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefmdof, ptr_->efm_dofid));
  }
  emscripten::val efm_L() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefmL, ptr_->efm_L));
  }
  emscripten::val efc_b() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_b));
  }
  emscripten::val iefc_aref() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_aref));
  }
  emscripten::val iefc_state() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_state));
  }
  emscripten::val iefc_force() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_force));
  }
  emscripten::val efc_state() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_state));
  }
  emscripten::val efc_force() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_force));
  }
  emscripten::val ifrc_constraint() const {
    return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->ifrc_constraint));
  }
  uint64_t signature() const {
    return ptr_->signature;
  }
  void set_signature(uint64_t value) {
    ptr_->signature = value;
  }
  // Generates functions to return accessor classes.
  #define X_ACCESSOR(NAME, Name, OBJTYPE, accessor_name, nfield)              \
    MjData##Name##Accessor accessor_name(const NumberOrString& val) const {   \
      if (val.isString()) {                                                   \
        int id = mj_name2id(model, OBJTYPE, val.as<std::string>().c_str());   \
        if (id == -1) {                                                       \
          mju_error("%s", KeyErrorMessage(model, OBJTYPE, model->nfield, val.as<std::string>(), #accessor_name).c_str());  \
        }                                                                     \
        return MjData##Name##Accessor(ptr_, model, id);                       \
      } else if (val.isNumber()) {                                            \
        int id = val.as<int>();                                               \
        if (id < 0 || id >= model->nfield) {                                  \
          mju_error("%s", IndexErrorMessage(id, model->nfield, #accessor_name).c_str());  \
        }                                                                     \
        return MjData##Name##Accessor(ptr_, model, id);                       \
      } else {                                                                \
        mju_error(#accessor_name "() argument must be a string or number");   \
        return MjData##Name##Accessor(nullptr, nullptr, 0);                   \
      }                                                                       \
    }
    MJDATA_ACCESSORS
  #undef X_ACCESSOR

 private:
  mjData* ptr_;

 public:
  std::vector<MjSolverStat> solver;
  std::vector<MjWarningStat> warning;
  std::vector<MjTimerStat> timer;
  mjModel *model;
};

struct MjsDefault {
  explicit MjsDefault(mjsDefault *ptr);
  mjsDefault* get() const;
  void set(mjsDefault* ptr);

 private:
  mjsDefault* ptr_;

 public:
  MjsElement element;
  MjsJoint joint;
  MjsGeom geom;
  MjsSite site;
  MjsCamera camera;
  MjsLight light;
  MjsFlex flex;
  MjsMesh mesh;
  MjsMaterial material;
  MjsPair pair;
  MjsEquality equality;
  MjsTendon tendon;
  MjsActuator actuator;
};


struct MjvScene {
  MjvScene();
  MjvScene(MjModel *m, int maxgeom);
  ~MjvScene();
  std::unique_ptr<MjvScene> copy();
  int GetSumFlexFaces() const;

  mjvScene* get() const;
  void set(mjvScene* ptr);

  std::vector<MjvGeom> geoms() const;

  emscripten::val geomorder() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->ngeom, ptr_->geomorder));
  }
  emscripten::val flexedgeadr() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexedgeadr));
  }
  emscripten::val flexedgenum() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexedgenum));
  }
  emscripten::val flexvertadr() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexvertadr));
  }
  emscripten::val flexvertnum() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexvertnum));
  }
  emscripten::val flexfaceadr() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfaceadr));
  }
  emscripten::val flexfacenum() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfacenum));
  }
  emscripten::val flexfaceused() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfaceused));
  }
  emscripten::val flexedge() const {
    return emscripten::val(
        emscripten::typed_memory_view(2 * model->nflexedge, ptr_->flexedge));
  }
  emscripten::val flexvert() const {
    return emscripten::val(
        emscripten::typed_memory_view(3 * model->nflexvert, ptr_->flexvert));
  }
  emscripten::val skinfacenum() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nskin, ptr_->skinfacenum));
  }
  emscripten::val skinvertadr() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nskin, ptr_->skinvertadr));
  }
  emscripten::val skinvertnum() const {
    return emscripten::val(
        emscripten::typed_memory_view(ptr_->nskin, ptr_->skinvertnum));
  }
  emscripten::val skinvert() const {
    return emscripten::val(
        emscripten::typed_memory_view(3 * model->nskinvert, ptr_->skinvert));
  }
  emscripten::val skinnormal() const {
    return emscripten::val(
        emscripten::typed_memory_view(3 * model->nskinvert, ptr_->skinnormal));
  }
  emscripten::val flexface() const {
    return emscripten::val(emscripten::typed_memory_view(
        9 * MjvScene::GetSumFlexFaces(), ptr_->flexface));
  }
  emscripten::val flexnormal() const {
    return emscripten::val(emscripten::typed_memory_view(
        9 * MjvScene::GetSumFlexFaces(), ptr_->flexnormal));
  }
  emscripten::val flextexcoord() const {
    return emscripten::val(emscripten::typed_memory_view(
        6 * MjvScene::GetSumFlexFaces(), ptr_->flextexcoord));
  }
  // camera field is handled manually in template file struct declaration
  // flexedge field is handled manually in template file struct declaration
  // flexedgeadr field is handled manually in template file struct declaration
  // flexedgenum field is handled manually in template file struct declaration
  // flexface field is handled manually in template file struct declaration
  // flexfaceadr field is handled manually in template file struct declaration
  // flexfacenum field is handled manually in template file struct declaration
  // flexfaceused field is handled manually in template file struct declaration
  // flexnormal field is handled manually in template file struct declaration
  // flextexcoord field is handled manually in template file struct declaration
  // flexvert field is handled manually in template file struct declaration
  // flexvertadr field is handled manually in template file struct declaration
  // flexvertnum field is handled manually in template file struct declaration
  // geomorder field is handled manually in template file struct declaration
  // geoms field is handled manually in template file struct declaration
  // lights field is handled manually in template file struct declaration
  // skinfacenum field is handled manually in template file struct declaration
  // skinnormal field is handled manually in template file struct declaration
  // skinvert field is handled manually in template file struct declaration
  // skinvertadr field is handled manually in template file struct declaration
  // skinvertnum field is handled manually in template file struct declaration
  emscripten::val flags() const {
    return emscripten::val(emscripten::typed_memory_view(11, ptr_->flags));
  }
  emscripten::val framergb() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->framergb));
  }
  emscripten::val rotate() const {
    return emscripten::val(emscripten::typed_memory_view(4, ptr_->rotate));
  }
  emscripten::val translate() const {
    return emscripten::val(emscripten::typed_memory_view(3, ptr_->translate));
  }
  float scale() const {
    return ptr_->scale;
  }
  void set_scale(float value) {
    ptr_->scale = value;
  }
  int framewidth() const {
    return ptr_->framewidth;
  }
  void set_framewidth(int value) {
    ptr_->framewidth = value;
  }
  int maxgeom() const {
    return ptr_->maxgeom;
  }
  void set_maxgeom(int value) {
    ptr_->maxgeom = value;
  }
  int nflex() const {
    return ptr_->nflex;
  }
  void set_nflex(int value) {
    ptr_->nflex = value;
  }
  int ngeom() const {
    return ptr_->ngeom;
  }
  void set_ngeom(int value) {
    ptr_->ngeom = value;
  }
  int nlight() const {
    return ptr_->nlight;
  }
  void set_nlight(int value) {
    ptr_->nlight = value;
  }
  int nskin() const {
    return ptr_->nskin;
  }
  void set_nskin(int value) {
    ptr_->nskin = value;
  }
  int status() const {
    return ptr_->status;
  }
  void set_status(int value) {
    ptr_->status = value;
  }
  int stereo() const {
    return ptr_->stereo;
  }
  void set_stereo(int value) {
    ptr_->stereo = value;
  }
  mjtByte enabletransform() const {
    return ptr_->enabletransform;
  }
  void set_enabletransform(mjtByte value) {
    ptr_->enabletransform = value;
  }
  mjtByte flexedgeopt() const {
    return ptr_->flexedgeopt;
  }
  void set_flexedgeopt(mjtByte value) {
    ptr_->flexedgeopt = value;
  }
  mjtByte flexfaceopt() const {
    return ptr_->flexfaceopt;
  }
  void set_flexfaceopt(mjtByte value) {
    ptr_->flexfaceopt = value;
  }
  mjtByte flexskinopt() const {
    return ptr_->flexskinopt;
  }
  void set_flexskinopt(mjtByte value) {
    ptr_->flexskinopt = value;
  }
  mjtByte flexvertopt() const {
    return ptr_->flexvertopt;
  }
  void set_flexvertopt(mjtByte value) {
    ptr_->flexvertopt = value;
  }

 private:
  mjvScene* ptr_;
  bool owned_ = false;

 public:
  mjModel* model;
  std::vector<MjvLight> lights;
  std::vector<MjvGLCamera> camera;
};

struct MjVFS {
  MjVFS() : ptr_(new mjVFS) { mj_defaultVFS(ptr_); }
  ~MjVFS() { mj_deleteVFS(ptr_); }
  void AddBuffer(const std::string& name, const emscripten::val& buffer) {
    std::vector<uint8_t> vec = emscripten::vecFromJSArray<uint8_t>(buffer);
    int result = mj_addBufferVFS(ptr_, name.c_str(), vec.data(), vec.size());
    if (result != 0) {
      mju_error("Could not add buffer to VFS: %d", result);
    }
  }
  void DeleteFile(const std::string& filename) {
    mj_deleteFileVFS(ptr_, filename.c_str());
  }
  mjVFS* get() const { return ptr_; }

 private:
  mjVFS* ptr_;
};

}  // namespace mujoco::wasm
// NOLINTEND(whitespace/semicolon)
// NOLINTEND(whitespace/line_length)

#endif  // MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_