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

#ifndef mozilla_dom_TestJSImplGenBinding_h

#define mozilla_dom_TestJSImplGenBinding_h

#include "GeckoProfiler.h"

#include "js/RootingAPI.h"

#include "jspubtd.h"

#include "mozilla/ErrorResult.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "mozilla/dom/CallbackFunction.h"

#include "mozilla/dom/CallbackInterface.h"

#include "mozilla/dom/Date.h"

#include "mozilla/dom/Nullable.h"

#include "mozilla/dom/PrototypeList.h"

#include "mozilla/dom/Record.h"

#include "mozilla/dom/ToJSValue.h"

#include "mozilla/dom/TypedArray.h"

#include "nsWeakReference.h"

class nsRenamedInterface;

namespace mozilla {

namespace dom {

class ArrayBufferOrLong;

class ByteStringOrLong;

class CanvasPatternOrCanvasGradient;

class CanvasPatternOrNullOrCanvasGradient;

struct Dict;

struct DictContainingDict;

struct DictContainingSequence;

struct DictForConstructor;

class DocGroup;

class DoubleOrByteString;

class DoubleOrString;

class DoubleOrSupportedType;

class DoubleOrUSVString;

class FloatOrString;

struct GrandparentDict;

class IndirectlyImplementedInterface;

class MyTestCallback;

struct NativePropertyHooks;

class ObjectOrLong;

class ObjectOrNullOrLong;

class OwningArrayBufferOrLong;

class OwningByteStringOrLong;

class OwningCanvasPatternOrCanvasGradient;

class OwningCanvasPatternOrNullOrCanvasGradient;

class OwningDoubleOrByteString;

class OwningDoubleOrString;

class OwningDoubleOrSupportedType;

class OwningDoubleOrUSVString;

class OwningFloatOrString;

class OwningObjectOrLong;

class OwningObjectOrNullOrLong;

class OwningStringOrObject;

class OwningSupportedTypeOrObject;

class OwningUnrestrictedDoubleOrString;

class OwningUnrestrictedFloatOrString;

class Promise;

class ProtoAndIfaceCache;

class StringOrObject;

class SupportedTypeOrObject;

class TestCImplementedInterface;

class TestCImplementedInterface2;

struct TestCImplementedInterface2Atoms;

struct TestCImplementedInterfaceAtoms;

class TestCallbackInterface;

class TestExternalInterface;

class TestInterface;

class TestJSImplInterface;

struct TestJSImplInterfaceAtoms;

class TestJSImplNoInterfaceObject;

struct TestJSImplNoInterfaceObjectAtoms;

class TestNavigator;

struct TestNavigatorAtoms;

class TestNavigatorWithConstructor;

struct TestNavigatorWithConstructorAtoms;

class TestNonWrapperCacheInterface;

class TestParentInterface;

class TestTreatAsNullCallback;

class UnrestrictedDoubleOrString;

class UnrestrictedFloatOrString;

} // namespace dom

} // namespace mozilla

namespace mozilla {

namespace dom {

enum class MyTestEnum : uint8_t {

  A,

  B,

  EndGuard_

};

namespace MyTestEnumValues {

extern const EnumEntry strings[3];

} // namespace MyTestEnumValues

bool

ToJSValue(JSContext* aCx, MyTestEnum aArgument, JS::MutableHandle<JS::Value> aValue);

class MyTestCallback : public CallbackFunction

{

public:

  explicit inline MyTestCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aCallbackGlobal, nsIGlobalObject* aIncumbentGlobal)

    : CallbackFunction(aCx, aCallback, aCallbackGlobal, aIncumbentGlobal)

  {

    MOZ_ASSERT(JS::IsCallable(mCallback));

  }

  explicit inline MyTestCallback(JSObject* aCallback, JSObject* aCallbackGlobal, const FastCallbackConstructor& )

    : CallbackFunction(aCallback, aCallbackGlobal, FastCallbackConstructor())

  {

    MOZ_ASSERT(JS::IsCallable(mCallback));

  }

  explicit inline MyTestCallback(JSObject* aCallback, JSObject* aCallbackGlobal, JSObject* aAsyncStack, nsIGlobalObject* aIncumbentGlobal)

    : CallbackFunction(aCallback, aCallbackGlobal, aAsyncStack, aIncumbentGlobal)

  {

    MOZ_ASSERT(JS::IsCallable(mCallback));

  }

  explicit inline MyTestCallback(CallbackFunction* aOther)

    : CallbackFunction(aOther)

  {

  }

  template <typename T>

  inline void

  Call(const T& thisVal, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JS::Realm* aRealm = nullptr)

  {

    MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");

    if (!aExecutionReason) {

      aExecutionReason = "MyTestCallback";

    }

    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aRealm);

    if (!s.GetContext()) {

      MOZ_ASSERT(aRv.Failed());

      return;

    }

    JS::Rooted<JS::Value> thisValJS(s.GetContext());

    if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {

      aRv.Throw(NS_ERROR_FAILURE);

      return;

    }

    return Call(s.GetContext(), thisValJS, aRv);

  }

  inline void

  Call(ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JS::Realm* aRealm = nullptr)

  {

    MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");

    if (!aExecutionReason) {

      aExecutionReason = "MyTestCallback";

    }

    CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aRealm);

    if (!s.GetContext()) {

      MOZ_ASSERT(aRv.Failed());

      return;

    }

    return Call(s.GetContext(), JS::UndefinedHandleValue, aRv);

  }

  template <typename T>

  inline void

  Call(const T& thisVal, const char* aExecutionReason = nullptr)

  {

    return Call(thisVal, IgnoreErrors(), aExecutionReason);

  }

  inline void

  Call(const char* aExecutionReason = nullptr)

  {

    return Call(IgnoreErrors(), aExecutionReason, eReportExceptions, nullptr);

  }

  inline bool

  operator==(const MyTestCallback& aOther) const

  {

    return CallbackFunction::operator==(aOther);

  }

private:

  void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, ErrorResult& aRv);

};

namespace binding_detail {

class FastMyTestCallback : public MyTestCallback

{

public:

  explicit inline FastMyTestCallback(JSObject* aCallback, JSObject* aCallbackGlobal)

    : MyTestCallback(aCallback, aCallbackGlobal, FastCallbackConstructor())

  {

  }

  inline void

  Trace(JSTracer* aTracer)

  {

    MyTestCallback::Trace(aTracer);

  }

  inline void

  FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)

  {

    MyTestCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);

  }

};

} // namespace binding_detail

namespace TestCImplementedInterface_Binding {

  typedef mozilla::dom::TestCImplementedInterface NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestCImplementedInterface* 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::TestCImplementedInterface,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  JSObject*

  GetProtoObject(JSContext* aCx);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

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

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestCImplementedInterface,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace TestCImplementedInterface_Binding

namespace TestCImplementedInterface2_Binding {

  typedef mozilla::dom::TestCImplementedInterface2 NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestCImplementedInterface2* 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::TestCImplementedInterface2,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  JSObject*

  GetProtoObject(JSContext* aCx);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

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

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestCImplementedInterface2,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace TestCImplementedInterface2_Binding

namespace TestJSImplInterface_Binding {

  typedef mozilla::dom::TestJSImplInterface NativeType;

  static const int32_t myLongConstant = 5;

  static const bool nonEnumerableConst = true;

#ifdef XP_WIN

#undef NO_ERROR

#endif // XP_WIN

  static const uint32_t NO_ERROR = 4294967295;

  MOZ_CAN_RUN_SCRIPT bool

  CollectJSONAttributes(JSContext* cx, JS::Handle<JSObject*> obj, mozilla::dom::TestJSImplInterface* self, JS::Rooted<JSObject*>& result);

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestJSImplInterface* 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::TestJSImplInterface,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  JSObject*

  GetProtoObject(JSContext* aCx);

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

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

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestJSImplInterface,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace TestJSImplInterface_Binding

namespace TestJSImplNoInterfaceObject_Binding {

  typedef mozilla::dom::TestJSImplNoInterfaceObject NativeType;

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestJSImplNoInterfaceObject* 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::TestJSImplNoInterfaceObject,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

} // namespace TestJSImplNoInterfaceObject_Binding

namespace TestNavigator_Binding {

  typedef mozilla::dom::TestNavigator NativeType;

  already_AddRefed<TestNavigator>

  ConstructNavigatorObject(JSContext* cx, JS::Handle<JSObject*> obj, ErrorResult& aRv);

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestNavigator* 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::TestNavigator,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

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

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestNavigator,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace TestNavigator_Binding

namespace TestNavigatorWithConstructor_Binding {

  typedef mozilla::dom::TestNavigatorWithConstructor NativeType;

  already_AddRefed<TestNavigatorWithConstructor>

  ConstructNavigatorObject(JSContext* cx, JS::Handle<JSObject*> obj, ErrorResult& aRv);

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::dom::TestNavigatorWithConstructor* 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::TestNavigatorWithConstructor,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

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

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestNavigatorWithConstructor,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace TestNavigatorWithConstructor_Binding

class TestJSImplInterfaceJSImpl : public CallbackInterface

{

public:

  explicit inline TestJSImplInterfaceJSImpl(JSContext* aCx, JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aCallbackGlobal, nsIGlobalObject* aIncumbentGlobal)

    : CallbackInterface(aCx, aCallback, aCallbackGlobal, aIncumbentGlobal)

  {

  }

  explicit inline TestJSImplInterfaceJSImpl(JSObject* aCallback, JSObject* aCallbackGlobal, const FastCallbackConstructor& )

    : CallbackInterface(aCallback, aCallbackGlobal, FastCallbackConstructor())

  {

  }

  explicit inline TestJSImplInterfaceJSImpl(JSObject* aCallback, JSObject* aCallbackGlobal, JSObject* aAsyncStack, nsIGlobalObject* aIncumbentGlobal)

    : CallbackInterface(aCallback, aCallbackGlobal, aAsyncStack, aIncumbentGlobal)

  {

  }

  void PassByte(int8_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int8_t ReceiveByte(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByte(const Optional<int8_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByteBeforeRequired(const Optional<int8_t>& arg1, int8_t arg2, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByteWithDefault(int8_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByteWithDefaultBeforeRequired(int8_t arg1, int8_t arg2, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableByte(const Nullable<int8_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableByte(const Optional<Nullable<int8_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicByte(const nsTArray<int8_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int8_t ReturnByteSideEffectFree(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int8_t ReturnDOMDependentByte(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int8_t ReturnConstantByte(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int8_t ReturnDeviceStateDependentByte(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassShort(int16_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int16_t ReceiveShort(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalShort(const Optional<int16_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalShortWithDefault(int16_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassLong(int32_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int32_t ReceiveLong(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalLong(const Optional<int32_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalLongWithDefault(int32_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassLongLong(int64_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  int64_t ReceiveLongLong(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalLongLong(const Optional<int64_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalLongLongWithDefault(int64_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOctet(uint8_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  uint8_t ReceiveOctet(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalOctet(const Optional<uint8_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalOctetWithDefault(uint8_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnsignedShort(uint16_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  uint16_t ReceiveUnsignedShort(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedShort(const Optional<uint16_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedShortWithDefault(uint16_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnsignedLong(uint32_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  uint32_t ReceiveUnsignedLong(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedLong(const Optional<uint32_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedLongWithDefault(uint32_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnsignedLongLong(uint64_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  uint64_t ReceiveUnsignedLongLong(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedLongLong(const Optional<uint64_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnsignedLongLongWithDefault(uint64_t arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassFloat(float arg1, float arg2, const Nullable<float>& arg3, const Nullable<float>& arg4, double arg5, double arg6, const Nullable<double>& arg7, const Nullable<double>& arg8, const Sequence<float>& arg9, const Sequence<float>& arg10, const Sequence<Nullable<float>>& arg11, const Sequence<Nullable<float>>& arg12, const Sequence<double>& arg13, const Sequence<double>& arg14, const Sequence<Nullable<double>>& arg15, const Sequence<Nullable<double>>& arg16, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassLenientFloat(float arg1, float arg2, const Nullable<float>& arg3, const Nullable<float>& arg4, double arg5, double arg6, const Nullable<double>& arg7, const Nullable<double>& arg8, const Sequence<float>& arg9, const Sequence<float>& arg10, const Sequence<Nullable<float>>& arg11, const Sequence<Nullable<float>>& arg12, const Sequence<double>& arg13, const Sequence<double>& arg14, const Sequence<Nullable<double>>& arg15, const Sequence<Nullable<double>>& arg16, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestJSImplInterface> ReceiveSelf(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestJSImplInterface> ReceiveNullableSelf(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestJSImplInterface> ReceiveWeakSelf(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestJSImplInterface> ReceiveWeakNullableSelf(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSelf(TestJSImplInterface& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSelf(TestJSImplInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSelf(const Optional<TestJSImplInterface*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNonNullSelf(const Optional<NonNull<TestJSImplInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSelfWithDefault(TestJSImplInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<RefPtr<TestNonWrapperCacheInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<RefPtr<TestNonWrapperCacheInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<IndirectlyImplementedInterface> ReceiveOther(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<IndirectlyImplementedInterface> ReceiveWeakOther(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<IndirectlyImplementedInterface> ReceiveWeakNullableOther(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOther(IndirectlyImplementedInterface& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableOther(IndirectlyImplementedInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalOtherWithDefault(IndirectlyImplementedInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestExternalInterface> ReceiveExternal(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestExternalInterface> ReceiveNullableExternal(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestExternalInterface> ReceiveWeakExternal(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestExternalInterface> ReceiveWeakNullableExternal(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassExternal(TestExternalInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableExternal(TestExternalInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalExternal(const Optional<TestExternalInterface*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNonNullExternal(const Optional<TestExternalInterface*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalExternalWithDefault(TestExternalInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestCallbackInterface> ReceiveCallbackInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestCallbackInterface> ReceiveNullableCallbackInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestCallbackInterface> ReceiveWeakCallbackInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<TestCallbackInterface> ReceiveWeakNullableCallbackInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCallbackInterface(TestCallbackInterface& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCallbackInterface(TestCallbackInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalCallbackInterface(const Optional<RefPtr<TestCallbackInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassConsequentialInterface(IndirectlyImplementedInterface& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveSequence(nsTArray<int32_t>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableSequence(Nullable<nsTArray<int32_t>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveSequenceOfNullableInts(nsTArray<Nullable<int32_t>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableSequenceOfNullableInts(Nullable<nsTArray<Nullable<int32_t>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequence(const Sequence<int32_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSequence(const Nullable<Sequence<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveCastableObjectSequence(nsTArray<RefPtr<TestJSImplInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveCallbackObjectSequence(nsTArray<RefPtr<TestCallbackInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableCastableObjectSequence(nsTArray<RefPtr<TestJSImplInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableCallbackObjectSequence(nsTArray<RefPtr<TestCallbackInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveCastableObjectNullableSequence(Nullable<nsTArray<RefPtr<TestJSImplInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableCastableObjectNullableSequence(Nullable<nsTArray<RefPtr<TestJSImplInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveWeakCastableObjectSequence(nsTArray<RefPtr<TestJSImplInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveWeakNullableCastableObjectSequence(nsTArray<RefPtr<TestJSImplInterface>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveWeakCastableObjectNullableSequence(Nullable<nsTArray<RefPtr<TestJSImplInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveWeakNullableCastableObjectNullableSequence(Nullable<nsTArray<RefPtr<TestJSImplInterface>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCastableObjectSequence(const Sequence<OwningNonNull<TestJSImplInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCastableObjectSequence(const Sequence<RefPtr<TestJSImplInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCastableObjectNullableSequence(const Nullable<Sequence<OwningNonNull<TestJSImplInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCastableObjectNullableSequence(const Nullable<Sequence<RefPtr<TestJSImplInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSequence(const Optional<Sequence<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSequenceWithDefaultValue(const Sequence<int32_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceWithDefaultValue(const Nullable<Sequence<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceWithDefaultValue2(const Nullable<Sequence<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestJSImplInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassExternalInterfaceSequence(const Sequence<RefPtr<TestExternalInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableExternalInterfaceSequence(const Sequence<RefPtr<TestExternalInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveStringSequence(nsTArray<nsString>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveByteStringSequence(nsTArray<nsCString>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveAnySequence(nsTArray<JS::Value>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableAnySequence(Nullable<nsTArray<JS::Value>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveObjectSequence(nsTArray<JSObject*>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableObjectSequence(nsTArray<JSObject*>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfSequences(const Sequence<Sequence<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfSequencesOfSequences(const Sequence<Sequence<Sequence<int32_t>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecord(const Record<nsString, int32_t>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableRecord(const Nullable<Record<nsString, int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfNullableInts(const Record<nsString, Nullable<int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalRecordOfNullableInts(const Optional<Record<nsString, Nullable<int32_t>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecordOfNullableInts(const Optional<Nullable<Record<nsString, Nullable<int32_t>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCastableObjectRecord(const Record<nsString, OwningNonNull<TestInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCastableObjectRecord(const Record<nsString, RefPtr<TestInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCastableObjectNullableRecord(const Nullable<Record<nsString, OwningNonNull<TestInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCastableObjectNullableRecord(const Nullable<Record<nsString, RefPtr<TestInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalRecord(const Optional<Record<nsString, int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecord(const Optional<Nullable<Record<nsString, int32_t>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecordWithDefaultValue(const Nullable<Record<nsString, int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalObjectRecord(const Optional<Record<nsString, OwningNonNull<TestInterface>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassExternalInterfaceRecord(const Record<nsString, RefPtr<TestExternalInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableExternalInterfaceRecord(const Record<nsString, RefPtr<TestExternalInterface>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassStringRecord(const Record<nsString, nsString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassByteStringRecord(const Record<nsString, nsCString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfRecords(const Record<nsString, Record<nsString, int32_t>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveRecord(Record<nsString, int32_t>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableRecord(Nullable<Record<nsString, int32_t>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveRecordOfNullableInts(Record<nsString, Nullable<int32_t>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableRecordOfNullableInts(Nullable<Record<nsString, Nullable<int32_t>>>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveAnyRecord(Record<nsString, JS::Value>& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassArrayBuffer(const ArrayBuffer& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableArrayBuffer(const Nullable<ArrayBuffer>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalArrayBuffer(const Optional<ArrayBuffer>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassArrayBufferView(const ArrayBufferView& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassInt8Array(const Int8Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassInt16Array(const Int16Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassInt32Array(const Int32Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUint8Array(const Uint8Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUint16Array(const Uint16Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUint32Array(const Uint32Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUint8ClampedArray(const Uint8ClampedArray& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassFloat32Array(const Float32Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassFloat64Array(const Float64Array& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfArrayBuffers(const Record<nsString, ArrayBuffer>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfNullableArrayBuffers(const Record<nsString, Nullable<ArrayBuffer>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicTypedArray(const nsTArray<Float32Array>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicNullableTypedArray(const nsTArray<Nullable<Float32Array>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveUint8Array(JS::MutableHandle<JSObject*> aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassString(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableString(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalString(const Optional<nsAString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalStringWithDefaultValue(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableString(const Optional<nsAString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableStringWithDefaultValue(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicString(const nsTArray<nsString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassByteString(const nsCString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableByteString(const nsCString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByteString(const Optional<nsCString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalByteStringWithDefaultValue(const nsCString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableByteString(const Optional<nsCString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableByteStringWithDefaultValue(const nsCString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicByteString(const nsTArray<nsCString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnionByteString(const ByteStringOrLong& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnionByteString(const Optional<ByteStringOrLong>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnionByteStringWithDefaultValue(const ByteStringOrLong& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSVS(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSVS(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSVS(const Optional<nsAString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSVSWithDefaultValue(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSVS(const Optional<nsAString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSVSWithDefaultValue(const nsAString& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicSVS(const nsTArray<nsString>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveSVS(nsString& aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassEnum(MyTestEnum arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableEnum(const Nullable<MyTestEnum>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalEnum(const Optional<MyTestEnum>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassEnumWithDefault(MyTestEnum arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableEnum(const Optional<Nullable<MyTestEnum>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableEnumWithDefaultValue(const Nullable<MyTestEnum>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableEnumWithDefaultValue2(const Nullable<MyTestEnum>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  MyTestEnum ReceiveEnum(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  Nullable<MyTestEnum> ReceiveNullableEnum(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassCallback(MyTestCallback& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableCallback(MyTestCallback* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalCallback(const Optional<OwningNonNull<MyTestCallback>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableCallback(const Optional<RefPtr<MyTestCallback>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableCallbackWithDefaultValue(MyTestCallback* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<MyTestCallback> ReceiveCallback(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  already_AddRefed<MyTestCallback> ReceiveNullableCallback(ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback* arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassAny(JS::Handle<JS::Value> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicAny(const nsTArray<JS::Value>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalAny(JS::Handle<JS::Value> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassAnyDefaultNull(JS::Handle<JS::Value> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfAny(const Sequence<JS::Value>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSequenceOfAny(const Nullable<Sequence<JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSequenceOfAny(const Optional<Sequence<JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfAny(const Optional<Nullable<Sequence<JS::Value>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalSequenceOfAnyWithDefaultValue(const Nullable<Sequence<JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfSequenceOfAny(const Sequence<Sequence<JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfNullableSequenceOfAny(const Sequence<Nullable<Sequence<JS::Value>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSequenceOfNullableSequenceOfAny(const Nullable<Sequence<Nullable<Sequence<JS::Value>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfNullableSequenceOfAny(const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfAny(const Record<nsString, JS::Value>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableRecordOfAny(const Nullable<Record<nsString, JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalRecordOfAny(const Optional<Record<nsString, JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecordOfAny(const Optional<Nullable<Record<nsString, JS::Value>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalRecordOfAnyWithDefaultValue(const Nullable<Record<nsString, JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfRecordOfAny(const Record<nsString, Record<nsString, JS::Value>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfNullableRecordOfAny(const Record<nsString, Nullable<Record<nsString, JS::Value>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableRecordOfNullableRecordOfAny(const Nullable<Record<nsString, Nullable<Record<nsString, JS::Value>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecordOfNullableRecordOfAny(const Optional<Nullable<Record<nsString, Nullable<Record<nsString, JS::Value>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableRecordOfNullableSequenceOfAny(const Optional<Nullable<Record<nsString, Nullable<Sequence<JS::Value>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfNullableRecordOfAny(const Optional<Nullable<Sequence<Nullable<Record<nsString, JS::Value>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveAny(JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassObject(JS::Handle<JSObject*> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicObject(const nsTArray<JSObject*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableObject(JS::Handle<JSObject*> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassVariadicNullableObject(const nsTArray<JSObject*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalObject(const Optional<JS::Handle<JSObject*>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableObject(const Optional<JS::Handle<JSObject*>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableObjectWithDefaultValue(JS::Handle<JSObject*> arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfObject(const Sequence<JSObject*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassSequenceOfNullableObject(const Sequence<JSObject*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableSequenceOfObject(const Nullable<Sequence<JSObject*>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfNullableSequenceOfObject(const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassRecordOfObject(const Record<nsString, JSObject*>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveObject(JS::MutableHandle<JSObject*> aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void ReceiveNullableObject(JS::MutableHandle<JSObject*> aRetVal, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnion(const ObjectOrLong& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnionWithNullable(const ObjectOrNullOrLong& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassNullableUnion(const Nullable<ObjectOrLong>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalUnion(const Optional<ObjectOrLong>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableUnion(const Optional<Nullable<ObjectOrLong>>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassOptionalNullableUnionWithDefaultValue(const Nullable<ObjectOrLong>& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnionWithArrayBuffer(const ArrayBufferOrLong& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);

  void PassUnionWithString(const StringOrObject& arg, ErrorResult& aRv, JS::Realm* aRealm = nullptr);