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

#ifndef mozilla_dom_NetDashboardBinding_h__
#define mozilla_dom_NetDashboardBinding_h__

#include "mozilla/ErrorResult.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/DOMJSClass.h"
#include "mozilla/dom/DOMJSProxyHandler.h"

namespace mozilla {
namespace dom {

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {

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

  inline ConnStatusDict()
  {
  }

private:
  ConnStatusDict(const ConnStatusDict&) MOZ_DELETE;
  void operator=(const ConnStatusDict) MOZ_DELETE;

  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);
};
struct ConnStatusDictInitializer : public ConnStatusDict
{
  inline ConnStatusDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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

  inline DNSCacheDict()
  {
  }

private:
  DNSCacheDict(const DNSCacheDict&) MOZ_DELETE;
  void operator=(const DNSCacheDict) MOZ_DELETE;

  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);
};
struct DNSCacheDictInitializer : public DNSCacheDict
{
  inline DNSCacheDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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

  inline DNSLookupDict()
  {
  }

private:
  DNSLookupDict(const DNSLookupDict&) MOZ_DELETE;
  void operator=(const DNSLookupDict) MOZ_DELETE;

  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);
};
struct DNSLookupDictInitializer : public DNSLookupDict
{
  inline DNSLookupDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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

  inline HalfOpenInfoDict()
  {
  }

private:
  HalfOpenInfoDict(const HalfOpenInfoDict&) MOZ_DELETE;
  void operator=(const HalfOpenInfoDict) MOZ_DELETE;

  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);
};
struct HalfOpenInfoDictInitializer : public HalfOpenInfoDict
{
  inline HalfOpenInfoDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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

  inline HttpConnInfoDict()
  {
  }

private:
  HttpConnInfoDict(const HttpConnInfoDict&) MOZ_DELETE;
  void operator=(const HttpConnInfoDict) MOZ_DELETE;

  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);
};
struct HttpConnInfoDictInitializer : public HttpConnInfoDict
{
  inline HttpConnInfoDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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;

  inline SocketsDict()
  {
  }

private:
  SocketsDict(const SocketsDict&) MOZ_DELETE;
  void operator=(const SocketsDict) MOZ_DELETE;

  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);
};
struct SocketsDictInitializer : public SocketsDict
{
  inline SocketsDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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;

  inline WebSocketDict()
  {
  }

private:
  WebSocketDict(const WebSocketDict&) MOZ_DELETE;
  void operator=(const WebSocketDict) MOZ_DELETE;

  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);
};
struct WebSocketDictInitializer : public WebSocketDict
{
  inline WebSocketDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


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;

  inline HttpConnDict()
  {
  }

private:
  HttpConnDict(const HttpConnDict&) MOZ_DELETE;
  void operator=(const HttpConnDict) MOZ_DELETE;

  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);
};
struct HttpConnDictInitializer : public HttpConnDict
{
  inline HttpConnDictInitializer()
  {
    // Safe to pass a null context if we pass a null value
    Init(nullptr, JS::NullHandleValue);
  }
};


} // namespace dom
} // namespace mozilla

#endif // mozilla_dom_NetDashboardBinding_h__
