/* THIS FILE IS AUTOGENERATED FROM SVGPathSeg.webidl BY Codegen.py - DO NOT EDIT */

#ifndef mozilla_dom_SVGPathSegBinding_h

#define mozilla_dom_SVGPathSegBinding_h

#include "GeckoProfiler.h"

#include "js/RootingAPI.h"

#include "jspubtd.h"

#include "mozilla/ErrorResult.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "mozilla/dom/Nullable.h"

#include "mozilla/dom/PrototypeList.h"

namespace mozilla {

class DOMSVGPathSeg;

class DOMSVGPathSegArcAbs;

struct DOMSVGPathSegArcAbsAtoms;

class DOMSVGPathSegArcRel;

struct DOMSVGPathSegArcRelAtoms;

struct DOMSVGPathSegAtoms;

class DOMSVGPathSegClosePath;

struct DOMSVGPathSegClosePathAtoms;

class DOMSVGPathSegCurvetoCubicAbs;

struct DOMSVGPathSegCurvetoCubicAbsAtoms;

class DOMSVGPathSegCurvetoCubicRel;

struct DOMSVGPathSegCurvetoCubicRelAtoms;

class DOMSVGPathSegCurvetoCubicSmoothAbs;

struct DOMSVGPathSegCurvetoCubicSmoothAbsAtoms;

class DOMSVGPathSegCurvetoCubicSmoothRel;

struct DOMSVGPathSegCurvetoCubicSmoothRelAtoms;

class DOMSVGPathSegCurvetoQuadraticAbs;

struct DOMSVGPathSegCurvetoQuadraticAbsAtoms;

class DOMSVGPathSegCurvetoQuadraticRel;

struct DOMSVGPathSegCurvetoQuadraticRelAtoms;

class DOMSVGPathSegCurvetoQuadraticSmoothAbs;

struct DOMSVGPathSegCurvetoQuadraticSmoothAbsAtoms;

class DOMSVGPathSegCurvetoQuadraticSmoothRel;

struct DOMSVGPathSegCurvetoQuadraticSmoothRelAtoms;

class DOMSVGPathSegLinetoAbs;

struct DOMSVGPathSegLinetoAbsAtoms;

class DOMSVGPathSegLinetoHorizontalAbs;

struct DOMSVGPathSegLinetoHorizontalAbsAtoms;

class DOMSVGPathSegLinetoHorizontalRel;

struct DOMSVGPathSegLinetoHorizontalRelAtoms;

class DOMSVGPathSegLinetoRel;

struct DOMSVGPathSegLinetoRelAtoms;

class DOMSVGPathSegLinetoVerticalAbs;

struct DOMSVGPathSegLinetoVerticalAbsAtoms;

class DOMSVGPathSegLinetoVerticalRel;

struct DOMSVGPathSegLinetoVerticalRelAtoms;

class DOMSVGPathSegMovetoAbs;

struct DOMSVGPathSegMovetoAbsAtoms;

class DOMSVGPathSegMovetoRel;

struct DOMSVGPathSegMovetoRelAtoms;

namespace dom {

struct NativePropertyHooks;

class ProtoAndIfaceCache;

} // namespace dom

} // namespace mozilla

namespace mozilla {

namespace dom {

namespace SVGPathSeg_Binding {

  typedef mozilla::DOMSVGPathSeg NativeType;

  static const uint16_t PATHSEG_UNKNOWN = 0;

  static const uint16_t PATHSEG_CLOSEPATH = 1;

  static const uint16_t PATHSEG_MOVETO_ABS = 2;

  static const uint16_t PATHSEG_MOVETO_REL = 3;

  static const uint16_t PATHSEG_LINETO_ABS = 4;

  static const uint16_t PATHSEG_LINETO_REL = 5;

  static const uint16_t PATHSEG_CURVETO_CUBIC_ABS = 6;

  static const uint16_t PATHSEG_CURVETO_CUBIC_REL = 7;

  static const uint16_t PATHSEG_CURVETO_QUADRATIC_ABS = 8;

  static const uint16_t PATHSEG_CURVETO_QUADRATIC_REL = 9;

  static const uint16_t PATHSEG_ARC_ABS = 10;

  static const uint16_t PATHSEG_ARC_REL = 11;

  static const uint16_t PATHSEG_LINETO_HORIZONTAL_ABS = 12;

  static const uint16_t PATHSEG_LINETO_HORIZONTAL_REL = 13;

  static const uint16_t PATHSEG_LINETO_VERTICAL_ABS = 14;

  static const uint16_t PATHSEG_LINETO_VERTICAL_REL = 15;

  static const uint16_t PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;

  static const uint16_t PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;

  static const uint16_t PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;

  static const uint16_t PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSeg,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  JSObject*

  GetProtoObject(JSContext* aCx);

} // namespace SVGPathSeg_Binding

namespace SVGPathSegArcAbs_Binding {

  typedef mozilla::DOMSVGPathSegArcAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegArcAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegArcAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegArcAbs_Binding

namespace SVGPathSegArcRel_Binding {

  typedef mozilla::DOMSVGPathSegArcRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegArcRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegArcRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegArcRel_Binding

namespace SVGPathSegClosePath_Binding {

  typedef mozilla::DOMSVGPathSegClosePath NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegClosePath* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegClosePath,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegClosePath_Binding

namespace SVGPathSegCurvetoCubicAbs_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoCubicAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoCubicAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoCubicAbs_Binding

namespace SVGPathSegCurvetoCubicRel_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoCubicRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoCubicRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoCubicRel_Binding

namespace SVGPathSegCurvetoCubicSmoothAbs_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoCubicSmoothAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicSmoothAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoCubicSmoothAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoCubicSmoothAbs_Binding

namespace SVGPathSegCurvetoCubicSmoothRel_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoCubicSmoothRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicSmoothRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoCubicSmoothRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoCubicSmoothRel_Binding

namespace SVGPathSegCurvetoQuadraticAbs_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoQuadraticAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoQuadraticAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoQuadraticAbs_Binding

namespace SVGPathSegCurvetoQuadraticRel_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoQuadraticRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoQuadraticRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoQuadraticRel_Binding

namespace SVGPathSegCurvetoQuadraticSmoothAbs_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoQuadraticSmoothAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticSmoothAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoQuadraticSmoothAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoQuadraticSmoothAbs_Binding

namespace SVGPathSegCurvetoQuadraticSmoothRel_Binding {

  typedef mozilla::DOMSVGPathSegCurvetoQuadraticSmoothRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticSmoothRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegCurvetoQuadraticSmoothRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegCurvetoQuadraticSmoothRel_Binding

namespace SVGPathSegLinetoAbs_Binding {

  typedef mozilla::DOMSVGPathSegLinetoAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoAbs_Binding

namespace SVGPathSegLinetoHorizontalAbs_Binding {

  typedef mozilla::DOMSVGPathSegLinetoHorizontalAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoHorizontalAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoHorizontalAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoHorizontalAbs_Binding

namespace SVGPathSegLinetoHorizontalRel_Binding {

  typedef mozilla::DOMSVGPathSegLinetoHorizontalRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoHorizontalRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoHorizontalRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoHorizontalRel_Binding

namespace SVGPathSegLinetoRel_Binding {

  typedef mozilla::DOMSVGPathSegLinetoRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoRel_Binding

namespace SVGPathSegLinetoVerticalAbs_Binding {

  typedef mozilla::DOMSVGPathSegLinetoVerticalAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoVerticalAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoVerticalAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoVerticalAbs_Binding

namespace SVGPathSegLinetoVerticalRel_Binding {

  typedef mozilla::DOMSVGPathSegLinetoVerticalRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoVerticalRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegLinetoVerticalRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegLinetoVerticalRel_Binding

namespace SVGPathSegMovetoAbs_Binding {

  typedef mozilla::DOMSVGPathSegMovetoAbs NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegMovetoAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegMovetoAbs,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegMovetoAbs_Binding

namespace SVGPathSegMovetoRel_Binding {

  typedef mozilla::DOMSVGPathSegMovetoRel NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::DOMSVGPathSegMovetoRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  // We declare this as an array so that retrieving a pointer to this

  // binding's property hooks only requires compile/link-time resolvable

  // address arithmetic.  Declaring it as a pointer instead would require

  // doing a run-time load to fetch a pointer to this binding's property

  // hooks.  And then structures which embedded a pointer to this structure

  // would require a run-time load for proper initialization, which would

  // then induce static constructors.  Lots of static constructors.

  extern const NativePropertyHooks sNativePropertyHooks[];

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::SVGPathSegMovetoRel,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace SVGPathSegMovetoRel_Binding

} // namespace dom

} // namespace mozilla

#endif // mozilla_dom_SVGPathSegBinding_h