/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#ifndef mozilla_dom_NetDashboardBinding_h__
#define mozilla_dom_NetDashboardBinding_h__

#include "js/RootingAPI.h"
#include "jspubtd.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/BindingDeclarations.h"

namespace mozilla {
namespace dom {

struct ConnStatusDictAtoms;
struct DNSCacheDictAtoms;
struct DNSLookupDictAtoms;
struct HalfOpenInfoDict;
struct HalfOpenInfoDictAtoms;
struct HttpConnDictAtoms;
struct HttpConnInfoDict;
struct HttpConnInfoDictAtoms;
class NativePropertyHooks;
struct SocketsDictAtoms;
struct WebSocketDictAtoms;

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {

struct ConnStatusDict : public MainThreadDictionaryBase
{
  Optional<nsString > mStatus;

  ConnStatusDict();

  explicit inline ConnStatusDict(const ConnStatusDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline ConnStatusDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, ConnStatusDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const ConnStatusDict& aOther);
};

namespace dictionary_detail {
struct FastConnStatusDict : public ConnStatusDict
{
  inline FastConnStatusDict()
    : ConnStatusDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct DNSCacheDict : public MainThreadDictionaryBase
{
  Optional<Sequence<double > > mExpiration;
  Optional<Sequence<nsString > > mFamily;
  Optional<Sequence<Sequence<nsString > > > mHostaddr;
  Optional<Sequence<nsString > > mHostname;

  DNSCacheDict();

  explicit inline DNSCacheDict(const DNSCacheDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline DNSCacheDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, DNSCacheDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const DNSCacheDict& aOther);
};

namespace dictionary_detail {
struct FastDNSCacheDict : public DNSCacheDict
{
  inline FastDNSCacheDict()
    : DNSCacheDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct DNSLookupDict : public MainThreadDictionaryBase
{
  Optional<Sequence<nsString > > mAddress;
  Optional<bool > mAnswer;
  Optional<nsString > mError;

  DNSLookupDict();

  explicit inline DNSLookupDict(const DNSLookupDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline DNSLookupDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, DNSLookupDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const DNSLookupDict& aOther);
};

namespace dictionary_detail {
struct FastDNSLookupDict : public DNSLookupDict
{
  inline FastDNSLookupDict()
    : DNSLookupDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct HalfOpenInfoDict : public MainThreadDictionaryBase
{
  Optional<Sequence<bool > > mSpeculative;

  HalfOpenInfoDict();

  explicit inline HalfOpenInfoDict(const HalfOpenInfoDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline HalfOpenInfoDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, HalfOpenInfoDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const HalfOpenInfoDict& aOther);
};

namespace dictionary_detail {
struct FastHalfOpenInfoDict : public HalfOpenInfoDict
{
  inline FastHalfOpenInfoDict()
    : HalfOpenInfoDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct HttpConnInfoDict : public MainThreadDictionaryBase
{
  Optional<Sequence<nsString > > mProtocolVersion;
  Optional<Sequence<uint32_t > > mRtt;
  Optional<Sequence<uint32_t > > mTtl;

  HttpConnInfoDict();

  explicit inline HttpConnInfoDict(const HttpConnInfoDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline HttpConnInfoDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, HttpConnInfoDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const HttpConnInfoDict& aOther);
};

namespace dictionary_detail {
struct FastHttpConnInfoDict : public HttpConnInfoDict
{
  inline FastHttpConnInfoDict()
    : HttpConnInfoDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct SocketsDict : public MainThreadDictionaryBase
{
  Optional<Sequence<bool > > mActive;
  Optional<Sequence<nsString > > mHost;
  Optional<Sequence<uint32_t > > mPort;
  double mReceived;
  double mSent;
  Optional<Sequence<double > > mSockreceived;
  Optional<Sequence<double > > mSocksent;
  Optional<Sequence<uint32_t > > mTcp;

  SocketsDict();

  explicit inline SocketsDict(const SocketsDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline SocketsDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, SocketsDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const SocketsDict& aOther);
};

namespace dictionary_detail {
struct FastSocketsDict : public SocketsDict
{
  inline FastSocketsDict()
    : SocketsDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct WebSocketDict : public MainThreadDictionaryBase
{
  Optional<Sequence<bool > > mEncrypted;
  Optional<Sequence<nsString > > mHostport;
  Optional<Sequence<uint32_t > > mMsgreceived;
  Optional<Sequence<uint32_t > > mMsgsent;
  Optional<Sequence<double > > mReceivedsize;
  Optional<Sequence<double > > mSentsize;

  WebSocketDict();

  explicit inline WebSocketDict(const WebSocketDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline WebSocketDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, WebSocketDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const WebSocketDict& aOther);
};

namespace dictionary_detail {
struct FastWebSocketDict : public WebSocketDict
{
  inline FastWebSocketDict()
    : WebSocketDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


struct HttpConnDict : public MainThreadDictionaryBase
{
  Optional<Sequence<HttpConnInfoDict > > mActive;
  Optional<Sequence<HalfOpenInfoDict > > mHalfOpens;
  Optional<Sequence<nsString > > mHost;
  Optional<Sequence<HttpConnInfoDict > > mIdle;
  Optional<Sequence<uint32_t > > mPort;
  Optional<Sequence<bool > > mSpdy;
  Optional<Sequence<bool > > mSsl;

  HttpConnDict();

  explicit inline HttpConnDict(const HttpConnDict& aOther)
  {
    *this = aOther;
  }

protected:
  explicit inline HttpConnDict(int )
  {
    // Do nothing here; this is used by our "Fast" subclass
  }

private:
  static bool
  InitIds(JSContext* cx, HttpConnDictAtoms* atomsCache);

public:
  bool
  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value");

  bool
  Init(const nsAString& aJSON);

  bool
  ToObject(JSContext* cx, JS::Handle<JSObject*> parentObject, JS::MutableHandle<JS::Value> rval) const;

  void
  TraceDictionary(JSTracer* trc);

  void
  operator=(const HttpConnDict& aOther);
};

namespace dictionary_detail {
struct FastHttpConnDict : public HttpConnDict
{
  inline FastHttpConnDict()
    : HttpConnDict(42)
  {
    // Doesn't matter what int we pass to the parent constructor
  }
};
} // namespace dictionary_detail


} // namespace dom
} // namespace mozilla

#endif // mozilla_dom_NetDashboardBinding_h__
