.. code-block:: cpp

     // Prototype
     static constexpr int index

  .. code-block:: cpp

     // Prototype
     static constexpr int index

  // Prototype
  template<typename Slot>
  struct allow_raw_pointer : public allow_raw_pointers

  // Prototype
  template<typename Signature>
  typename std::add_pointer<Signature>::type select_overload(typename std::add_pointer<Signature>::type fn)

  // Prototype
  template<typename Signature, typename ClassType>
  typename internal::MemberFunctionType<ClassType, Signature>::type select_overload(Signature (ClassType::*fn))

  // Prototype
  template<typename ClassType, typename ReturnType, typename... Args>
  auto select_const(ReturnType (ClassType::*method)(Args...) const)

  // Prototype
  template<typename LambdaType>
  typename internal::CalculateLambdaSignature<LambdaType>::type optional_override(const LambdaType& fp)

  //prototype
  template<typename ReturnType, typename... Args, typename... Policies>
  void function(const char* name, ReturnType (*fn)(Args...), Policies...)

  // quick_example.cpp
  #include <emscripten/bind.h>

  using namespace emscripten;

  float lerp(float a, float b, float t) {
     return (1 - t) * a + t * b;
  }

  EMSCRIPTEN_BINDINGS(my_module) {
     function("lerp", &lerp);
  }

  A typedef of ``ClassType``, the typename of the templated type for the class.

  Constructor.

  :param const char* name:

  Destructor.

  :param ElementType InstanceType::\*field: Note that ``ElementType`` and ``InstanceType`` are typenames (templated types).

  :param Getter getter: Note that ``Getter`` is a typename (templated type).
  :param Setter setter: Note that ``Setter`` is a typename (templated type).

  :param index<Index>: Note that ``Index`` is an integer template parameter.

  A typedef of ``ClassType``, the typename of the templated type for the class.

  Constructor.

  :param const char* name:

  Destructor.

  :param const char* fieldName:
  :param FieldType InstanceType\:\:\*field:

  :param const char* fieldName:
  :param Getter getter: Note that ``Getter`` is a typename (templated type).
  :param Setter setter: Note that ``Setter`` is a typename (templated type).

  :param const char* fieldName:
  :param index<Index>: Note that ``Index`` is an integer template parameter.

  //prototype
  template<typename PointerType>
  struct default_smart_ptr_trait

  :param void* v:

  :returns: Note that the ``PointerType`` returned is a typename (templated type).

  //prototype
  template<typename PointerType>
  struct smart_ptr_trait : public default_smart_ptr_trait<PointerType>

  .. code-block:: cpp

     //prototype
     typedef typename PointerType::element_type element_type;


  A typedef for the PointerType::element_type, where ``PointerType`` is a typename (templated type).

  :param const PointerType& ptr: Note that ``PointerType`` is a typename (templated type)

  //prototype
  template<typename PointeeType>
  struct smart_ptr_trait<std::shared_ptr<PointeeType>>

  A typedef to std::shared_ptr<PointeeType>, where ``PointeeType`` is a typename (templated type).

  A typedef for the ``PointerType::element_type``.

  :param const PointerType& ptr:

  :param PointeeType* p: Note that ``PointeeType`` is a typename (templated type).
  :param EM_VAL v:

  //prototype
  template<typename T>
  class wrapper : public T, public internal::WrapperBase

  A typedef of ``T``, the typename of the templated type for the class.

  .. code-block:: cpp

     //prototype
     template<typename... Args>
     explicit wrapper(val&& wrapped, Args&&... args)
       : T(std::forward<Args>(args)...)
       , wrapped(std::forward<val>(wrapped))

  Constructor.

  :param val&& wrapped:
  :param Args&&... args: Note that ``Args`` is a typename (templated type).

  Destructor.

  Constructor.

  :param const char* name:
  :param Args&&... args: Note that ``Args`` is a typename (templated type).
  :returns: Note that ``ReturnType`` is a typename (templated type).

  A typedef of ``BaseClass``, the typename of the templated type for the class.

  Note, is templated function which takes typename ``ClassType``.

  .. code-block:: cpp

     template<typename ClassType>
     using Upcaster = BaseClass* (*)(ClassType*);

     template<typename ClassType>
     using Downcaster = ClassType* (*)(BaseClass*);

  .. code-block:: cpp

     //prototype
     template<typename ClassType>
     static Upcaster<ClassType> getUpcaster()

  .. code-block:: cpp

     //prototype
     template<typename ClassType>
     static Downcaster<ClassType> getDowncaster()

  .. code-block:: cpp

     //prototype
     template<typename From, typename To>
     static To* convertPointer(From* ptr)

  :param From* ptr:

  Note that this is a templated struct taking typename parameter ``InputType`` and integer ``Index``.

  .. cpp:type:: type

     This is a typedef to the parent struct typename parameter ``InputType``.

  A typedef of ``ClassType`` (a typename for the class).

  A typedef of ``BaseSpecifier`` (a typename for the class).

  ::

     class_() = delete;

  .. code-block:: cpp

     //prototype
     EMSCRIPTEN_ALWAYS_INLINE explicit class_(const char* name)


  Constructor.

  :param const char* name:

  .. code-block:: cpp

     //prototype
     template<typename PointerType>
     EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr(const char* name) const

  :param const char* name:
  :returns: |class_-function-returns|


  .. _embind-class-zero-argument-constructor:

  .. code-block:: cpp

     //prototype
     template<typename... ConstructorArgs, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Policies... policies) const

  Zero-argument form of the class constructor. This invokes the natural constructor with the arguments specified in the template. See :ref:`embind-external-constructors` for more information.

  :param Policies... policies: |policies-argument|
  :returns: |class_-function-returns|

  .. _embind-class-function-pointer-constructor:

  .. code-block:: cpp

     //prototype
     template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Callable callable, Policies...) const

  Class constructor for objects that use a factory function to create the object.  This method will accept either a function pointer, ``std::function``
  object or function object which will return a newly constructed object.  When the ``Callable`` is a function object the function signature must be
  explicitly specified in the ``Signature`` template parameter in the format ``ReturnType (Args...)``.  For ``Callable`` types other than function objects
  the method signature will be deduced.

  The following are all valid calls to ``constructor``:

  .. code-block:: cpp

     using namespace std::placeholders;
     myClass1.constructor(&my_factory);
     myClass2.constructor(std::function<ClassType2(float, float)>(&class2_factory));
     myClass3.constructor<ClassType3(const val&)>(std::bind(Class3Functor(), _1));

  See :ref:`embind-external-constructors` for more information.


  :param Callable callable: Note that ``Callable`` may be either a member function pointer, function pointer, ``std::function`` or function object.
  :param Policies... policies: |policies-argument|
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename SmartPtr, typename... Args, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr_constructor(const char* smartPtrName, SmartPtr (*factory)(Args...), Policies...) const

  :param const char* smartPtrName:
  :param SmartPtr (\*factory)(Args...):
  :param Policies... policies: |policies-argument|
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
      template<typename WrapperType, typename PointerType, typename... ConstructorArgs>
     EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
       const char* wrapperClassName,
       const char* pointerName,
       ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
     ) const

  :param const char* wrapperClassName:
  :param const char* pointerName:
  :param emscripten\:\:constructor<ConstructorArgs...> constructor):
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename WrapperType, typename... ConstructorArgs>
     EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
       const char* wrapperClassName,
       ::emscripten::constructor<ConstructorArgs...> constructor = ::emscripten::constructor<>()
     ) const

  :param const char* wrapperClassName:
  :param \:\:emscripten\:\:constructor<ConstructorArgs...> constructor):

  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& function(const char* methodName, Callable callable, Policies...) const

  This method is for declaring a method belonging to a class.

  On the JavaScript side this is a function that gets bound as a property of the prototype. For example ``.function("myClassMember", &MyClass::myClassMember)``
  would bind ``myClassMember`` to ``MyClass.prototype.myClassMember`` in the JavaScript.  This method will accept either a pointer-to-member-function, function
  pointer, ``std::function`` object or function object.  When the ``Callable`` is not a pointer-to-member-function it must accept the ``ClassType`` as the first
  (``this``) parameter.  When the ``Callable`` is a function object the function signature must be explicitly specified in the ``Signature`` template parameter
  in the format ``ReturnType (Args...)``.  For ``Callable`` types other than function objects the method signature will be deduced.

  A method name specified in the human-readable well-known symbol format (e.g., ``@@iterator``)
  is bound using the named ``Symbol`` for JavaScript (e.g., ``Symbol.iterator``).

  The following are all valid calls to ``function``:

  .. code-block:: cpp

     using namespace std::placeholders;
     myClass.function("myClassMember", &MyClass::myClassMember)
         .function("myFreeFunction", &my_free_function)
         .function("myStdFunction", std::function<float(ClassType&, float, float)>(&my_function))
         .function<val(const MyClass&)>("myFunctor", std::bind(&my_functor_taking_this, _1));


  :param const char* methodName:
  :param Callable callable: Note that ``Callable`` may be either a member function pointer, function pointer, ``std::function`` or function object.
  :param typename... Policies: |policies-argument|
  :returns: |class_-function-returns|

  .. code-block:: cpp

     // prototype
     template<typename ElementType>
     EMSCRIPTEN_ALWAYS_INLINE const class_& iterable(const char* sizeMethodName, const char* getMethodName) const

  Makes a bound class iterable in JavaScript by installing ``Symbol.iterator``.
  This enables use with ``for...of`` loops, ``Array.from()``, and spread syntax.

  :tparam ElementType: The type of elements yielded by the iterator.

  :param sizeMethodName: Name of the bound method that returns the number of elements.

  :param getMethodName: Name of the bound method that retrieves an element by index.

  :returns: |class_-function-returns|

  .. code-block:: cpp

     class_<MyContainer>("MyContainer")
        .function("size", &MyContainer::size)
        .function("get", &MyContainer::get)
        .iterable<int>("size", "get");

  .. code-block:: javascript

     const container = new Module.MyContainer();
     for (const item of container) { /* ... */ }
     const arr = Array.from(container);

  .. code-block:: cpp

     //prototype
     template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
     EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, const FieldType ClassType::*field) const

  :param const char* fieldName:
  :param const FieldType ClassType\:\:\*field:

  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
     EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, FieldType ClassType::*field) const

  :param const char* fieldName:
  :param FieldType ClassType\:\:\*field:

  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter>
     EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter) const;

  Declare a read-only property with the specified ``fieldName`` on the class using the specified ``getter`` to retrieve the property
  value.  ``Getter`` may be either a class method, a function, a ``std::function`` or a function object.  When ``Getter``
  is not pointer-to-member-function, it must accept an instance of the ``ClassType`` as the ``this`` argument.  When
  ``Getter`` is a function object, the property type must be specified as a template parameter as it cannot be deduced,
  e.g.: ``myClass.property<int>("myIntProperty", MyIntGetterFunctor());``

  :param const char* fieldName:
  :param Getter getter: Note that ``Getter`` is a function template typename.
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter, typename Setter>
     EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter, Setter setter) const

  This is a function template taking typenames ``Setter`` and ``Getter``: ``template<typename Getter, typename Setter>``
  which declares a read-write property with the specified ``fieldName`` on the class. ``Getter`` and ``Setter`` may be either a
  class method, a function, a ``std::function`` or a function object.  When ``Getter`` or ``Setter`` is not pointer-to-member-function,
  it must accept an instance of the ``ClassType`` as the ``this`` argument. When ``Getter`` or ``Setter`` is a function object, the
  property type must be specified as a template parameter as it cannot be deduced, e.g.:
  ``myClass.property<int>("myIntProperty", MyIntGetterFunctor(), MyIntSetterFunctor());``

  :param const char* fieldName:
  :param Getter getter: Note that ``Getter`` is a function template typename.
  :param Setter setter: Note that ``Setter`` is a function template typename.
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename ReturnType, typename... Args, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& class_function(const char* methodName, ReturnType (*classMethod)(Args...), Policies...) const

  This method is for declaring a static function belonging to a class.

  On the JavaScript side this is a function that gets bound as a property
  of the constructor. For example ``.class_function("myStaticFunction",
  &MyClass::myStaticFunction)`` binds ``myStaticFunction`` to
  ``MyClass.myStaticFunction``.

  A method name specified in the human-readable well-known symbol format (e.g., ``@@species``)
  is bound using the named ``Symbol`` for JavaScript (e.g., ``Symbol.species``).

  :param const char* methodName:
  :param ReturnType (\*classMethod)(Args...):
  :param Policies...: |policies-argument|
  :returns: |class_-function-returns|

  .. code-block:: cpp

     //prototype
     template<typename FieldType>
     EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, FieldType *field) const

  :param const char* fieldName:
  :param FieldType ClassType\:\:\*field:

  :returns: |class_-function-returns|

  //prototype
  template<typename T>
  class_<std::vector<T>> register_vector(const char* name)

  //prototype
  template<typename K, typename V>
  class_<std::map<K, V>> register_map(const char* name)

  //prototype
  template<typename EnumType>
  class enum_

  A typedef of ``EnumType`` (a typename for the class).

  Constructor.

  :param const char* name: Name of the enum in JavaScript.
  :param enum_value_type valueType:
      Determines how the enumerated values are represented in JavaScript.

      Possible values:

      - ``enum_value_type::object`` (default):
        Values are JavaScript objects with a ``.value`` field.

      - ``enum_value_type::number``:
        Values are plain numbers matching their corresponding C++ values.

      - ``enum_value_type::string``:
        Values are strings containing their name.

  Registers an enum value.

  :param const char* name: The name of the enumerated value.
  :param EnumType value: The enumerated value.
  :returns: A reference to the current object. This allows chaining of multiple enum values in the :cpp:func:`EMSCRIPTEN_BINDINGS` block.

  //prototype
  template<typename ConstantType>
  void constant(const char* name, const ConstantType& v)

  EMSCRIPTEN_BINDINGS(my_constant_example) {
    constant("SOME_CONSTANT", SOME_CONSTANT);
  }