//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef JSIPCValue_h
#define JSIPCValue_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/dom/ClientIPCTypes.h"
#include "mozilla/dom/DOMTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCDOMRect|
//
namespace mozilla {
namespace dom {
class JSIPCDOMRect final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    JSIPCDOMRect() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT JSIPCDOMRect(
            const double& _x,
            const double& _y,
            const double& _width,
            const double& _height) :
        x_(_x),
        y_(_y),
        width_(_width),
        height_(_height)
    {
    }

    MOZ_IMPLICIT JSIPCDOMRect(
            double&& _x,
            double&& _y,
            double&& _width,
            double&& _height) :
        x_(std::move(_x)),
        y_(std::move(_y)),
        width_(std::move(_width)),
        height_(std::move(_height))
    {
    }

    double&
    x()
    {
        return x_;
    }
    const double&
    x() const
    {
        return x_;
    }

    double&
    y()
    {
        return y_;
    }
    const double&
    y() const
    {
        return y_;
    }

    double&
    width()
    {
        return width_;
    }
    const double&
    width() const
    {
        return width_;
    }

    double&
    height()
    {
        return height_;
    }
    const double&
    height() const
    {
        return height_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<double> x_;
    ::mozilla::ipc::IPDLStructMember<double> y_;
    ::mozilla::ipc::IPDLStructMember<double> width_;
    ::mozilla::ipc::IPDLStructMember<double> height_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCDOMRect>
{
    typedef ::mozilla::dom::JSIPCDOMRect paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

namespace mozilla {
namespace dom {
class JSIPCProperty;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCArray;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCSet;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class JSIPCMapEntry;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union JSIPCValue|
//
namespace mozilla {
namespace dom {
class JSIPCValue final
{
public:
    enum Type {
        T__None,
        Tvoid_t = 1,
        Tnull_t,
        TnsString,
        Tbool,
        Tdouble,
        Tint32_t,
        TStructuredCloneData,
        TClonedMessageData,
        TnsIPrincipal,
        TMaybeDiscardedBrowsingContext,
        TJSIPCDOMRect,
        TArrayOfJSIPCProperty,
        TJSIPCArray,
        TJSIPCSet,
        TArrayOfJSIPCMapEntry,
        T__Last = TArrayOfJSIPCMapEntry
    };

private:
    typedef ::mozilla::void_t void_t;
    typedef ::mozilla::null_t null_t;
    typedef ::nsString nsString;
    typedef ::int32_t int32_t;
    typedef ::mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
    typedef ::mozilla::dom::ClonedMessageData ClonedMessageData;
    typedef ::nsIPrincipal nsIPrincipal;
    typedef ::mozilla::dom::MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext;
    typedef ::mozilla::dom::JSIPCDOMRect JSIPCDOMRect;
    typedef ::mozilla::dom::JSIPCProperty JSIPCProperty;
    typedef ::mozilla::dom::JSIPCArray JSIPCArray;
    typedef ::mozilla::dom::JSIPCSet JSIPCSet;
    typedef ::mozilla::dom::JSIPCMapEntry JSIPCMapEntry;
    typedef void_t void_t__tdef;
    typedef null_t null_t__tdef;
    typedef nsString nsString__tdef;
    typedef bool bool__tdef;
    typedef double double__tdef;
    typedef int32_t int32_t__tdef;
    typedef UniquePtr<StructuredCloneData> StructuredCloneData__tdef;
    typedef UniquePtr<ClonedMessageData> ClonedMessageData__tdef;
    typedef mozilla::NotNull<RefPtr<nsIPrincipal>> nsIPrincipal__tdef;
    typedef MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext__tdef;
    typedef JSIPCDOMRect JSIPCDOMRect__tdef;
    typedef nsTArray<JSIPCProperty>* ArrayOfJSIPCProperty__tdef;
    typedef JSIPCArray* JSIPCArray__tdef;
    typedef JSIPCSet* JSIPCSet__tdef;
    typedef nsTArray<JSIPCMapEntry>* ArrayOfJSIPCMapEntry__tdef;

    void_t*
    ptr_void_t()
    {
        return (&(mVvoid_t));
    }
    const void_t*
    constptr_void_t() const
    {
        return (&(mVvoid_t));
    }
    null_t*
    ptr_null_t()
    {
        return (&(mVnull_t));
    }
    const null_t*
    constptr_null_t() const
    {
        return (&(mVnull_t));
    }
    nsString*
    ptr_nsString()
    {
        return (&(mVnsString));
    }
    const nsString*
    constptr_nsString() const
    {
        return (&(mVnsString));
    }
    bool*
    ptr_bool()
    {
        return (&(mVbool));
    }
    const bool*
    constptr_bool() const
    {
        return (&(mVbool));
    }
    double*
    ptr_double()
    {
        return (&(mVdouble));
    }
    const double*
    constptr_double() const
    {
        return (&(mVdouble));
    }
    int32_t*
    ptr_int32_t()
    {
        return (&(mVint32_t));
    }
    const int32_t*
    constptr_int32_t() const
    {
        return (&(mVint32_t));
    }
    UniquePtr<StructuredCloneData>*
    ptr_StructuredCloneData()
    {
        return (&(mVStructuredCloneData));
    }
    const UniquePtr<StructuredCloneData>*
    constptr_StructuredCloneData() const
    {
        return (&(mVStructuredCloneData));
    }
    UniquePtr<ClonedMessageData>*
    ptr_ClonedMessageData()
    {
        return (&(mVClonedMessageData));
    }
    const UniquePtr<ClonedMessageData>*
    constptr_ClonedMessageData() const
    {
        return (&(mVClonedMessageData));
    }
    mozilla::NotNull<RefPtr<nsIPrincipal>>*
    ptr_nsIPrincipal()
    {
        return (&(mVnsIPrincipal));
    }
    const mozilla::NotNull<RefPtr<nsIPrincipal>>*
    constptr_nsIPrincipal() const
    {
        return (&(mVnsIPrincipal));
    }
    MaybeDiscardedBrowsingContext*
    ptr_MaybeDiscardedBrowsingContext()
    {
        return (&(mVMaybeDiscardedBrowsingContext));
    }
    const MaybeDiscardedBrowsingContext*
    constptr_MaybeDiscardedBrowsingContext() const
    {
        return (&(mVMaybeDiscardedBrowsingContext));
    }
    JSIPCDOMRect*
    ptr_JSIPCDOMRect()
    {
        return (&(mVJSIPCDOMRect));
    }
    const JSIPCDOMRect*
    constptr_JSIPCDOMRect() const
    {
        return (&(mVJSIPCDOMRect));
    }
    nsTArray<JSIPCProperty>*&
    ptr_ArrayOfJSIPCProperty()
    {
        return mVArrayOfJSIPCProperty;
    }
    const nsTArray<JSIPCProperty>*
    constptr_ArrayOfJSIPCProperty() const
    {
        return mVArrayOfJSIPCProperty;
    }
    JSIPCArray*&
    ptr_JSIPCArray()
    {
        return mVJSIPCArray;
    }
    const JSIPCArray*
    constptr_JSIPCArray() const
    {
        return mVJSIPCArray;
    }
    JSIPCSet*&
    ptr_JSIPCSet()
    {
        return mVJSIPCSet;
    }
    const JSIPCSet*
    constptr_JSIPCSet() const
    {
        return mVJSIPCSet;
    }
    nsTArray<JSIPCMapEntry>*&
    ptr_ArrayOfJSIPCMapEntry()
    {
        return mVArrayOfJSIPCMapEntry;
    }
    const nsTArray<JSIPCMapEntry>*
    constptr_ArrayOfJSIPCMapEntry() const
    {
        return mVArrayOfJSIPCMapEntry;
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT JSIPCValue() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT JSIPCValue(const void_t& aOther);

    MOZ_IMPLICIT JSIPCValue(void_t&& aOther);

    MOZ_IMPLICIT JSIPCValue(const null_t& aOther);

    MOZ_IMPLICIT JSIPCValue(null_t&& aOther);

    MOZ_IMPLICIT JSIPCValue(const nsString& aOther);

    MOZ_IMPLICIT JSIPCValue(nsString&& aOther);

    MOZ_IMPLICIT JSIPCValue(const bool& aOther);

    MOZ_IMPLICIT JSIPCValue(bool&& aOther);

    MOZ_IMPLICIT JSIPCValue(const double& aOther);

    MOZ_IMPLICIT JSIPCValue(double&& aOther);

    MOZ_IMPLICIT JSIPCValue(const int32_t& aOther);

    MOZ_IMPLICIT JSIPCValue(int32_t&& aOther);

    MOZ_IMPLICIT JSIPCValue(UniquePtr<StructuredCloneData>&& aOther);

    MOZ_IMPLICIT JSIPCValue(UniquePtr<ClonedMessageData>&& aOther);

    MOZ_IMPLICIT JSIPCValue(mozilla::NotNull<nsIPrincipal*> aOther);

    MOZ_IMPLICIT JSIPCValue(mozilla::NotNull<RefPtr<nsIPrincipal>>&& aOther);

    MOZ_IMPLICIT JSIPCValue(const MaybeDiscardedBrowsingContext& aOther);

    MOZ_IMPLICIT JSIPCValue(MaybeDiscardedBrowsingContext&& aOther);

    MOZ_IMPLICIT JSIPCValue(const JSIPCDOMRect& aOther);

    MOZ_IMPLICIT JSIPCValue(JSIPCDOMRect&& aOther);

    MOZ_IMPLICIT JSIPCValue(nsTArray<JSIPCProperty>&& aOther);

    MOZ_IMPLICIT JSIPCValue(JSIPCArray&& aOther);

    MOZ_IMPLICIT JSIPCValue(JSIPCSet&& aOther);

    MOZ_IMPLICIT JSIPCValue(nsTArray<JSIPCMapEntry>&& aOther);

    MOZ_IMPLICIT JSIPCValue(JSIPCValue&& aOther);

    ~JSIPCValue();

    Type
    type() const
    {
        return mType;
    }

    JSIPCValue&
    operator=(const void_t& aRhs);

    JSIPCValue&
    operator=(void_t&& aRhs);

    JSIPCValue&
    operator=(const null_t& aRhs);

    JSIPCValue&
    operator=(null_t&& aRhs);

    JSIPCValue&
    operator=(const nsString& aRhs);

    JSIPCValue&
    operator=(nsString&& aRhs);

    JSIPCValue&
    operator=(const bool& aRhs);

    JSIPCValue&
    operator=(bool&& aRhs);

    JSIPCValue&
    operator=(const double& aRhs);

    JSIPCValue&
    operator=(double&& aRhs);

    JSIPCValue&
    operator=(const int32_t& aRhs);

    JSIPCValue&
    operator=(int32_t&& aRhs);

    JSIPCValue&
    operator=(UniquePtr<StructuredCloneData>&& aRhs);

    JSIPCValue&
    operator=(UniquePtr<ClonedMessageData>&& aRhs);

    JSIPCValue&
    operator=(mozilla::NotNull<nsIPrincipal*> aRhs);

    JSIPCValue&
    operator=(mozilla::NotNull<RefPtr<nsIPrincipal>>&& aRhs);

    JSIPCValue&
    operator=(const MaybeDiscardedBrowsingContext& aRhs);

    JSIPCValue&
    operator=(MaybeDiscardedBrowsingContext&& aRhs);

    JSIPCValue&
    operator=(const JSIPCDOMRect& aRhs);

    JSIPCValue&
    operator=(JSIPCDOMRect&& aRhs);

    JSIPCValue&
    operator=(nsTArray<JSIPCProperty>&& aRhs);

    JSIPCValue&
    operator=(JSIPCArray&& aRhs);

    JSIPCValue&
    operator=(JSIPCSet&& aRhs);

    JSIPCValue&
    operator=(nsTArray<JSIPCMapEntry>&& aRhs);

    JSIPCValue&
    operator=(JSIPCValue&& aRhs);

    void_t&
    get_void_t()
    {
        AssertSanity(Tvoid_t);
        return (*(ptr_void_t()));
    }
    const void_t&
    get_void_t() const
    {
        AssertSanity(Tvoid_t);
        return (*(constptr_void_t()));
    }
    operator void_t&()
    {
        return get_void_t();
    }
    operator const void_t&() const
    {
        return get_void_t();
    }

    null_t&
    get_null_t()
    {
        AssertSanity(Tnull_t);
        return (*(ptr_null_t()));
    }
    const null_t&
    get_null_t() const
    {
        AssertSanity(Tnull_t);
        return (*(constptr_null_t()));
    }
    operator null_t&()
    {
        return get_null_t();
    }
    operator const null_t&() const
    {
        return get_null_t();
    }

    nsString&
    get_nsString()
    {
        AssertSanity(TnsString);
        return (*(ptr_nsString()));
    }
    const nsString&
    get_nsString() const
    {
        AssertSanity(TnsString);
        return (*(constptr_nsString()));
    }
    operator nsString&()
    {
        return get_nsString();
    }
    operator const nsString&() const
    {
        return get_nsString();
    }

    bool&
    get_bool()
    {
        AssertSanity(Tbool);
        return (*(ptr_bool()));
    }
    const bool&
    get_bool() const
    {
        AssertSanity(Tbool);
        return (*(constptr_bool()));
    }
    operator bool&()
    {
        return get_bool();
    }
    operator const bool&() const
    {
        return get_bool();
    }

    double&
    get_double()
    {
        AssertSanity(Tdouble);
        return (*(ptr_double()));
    }
    const double&
    get_double() const
    {
        AssertSanity(Tdouble);
        return (*(constptr_double()));
    }
    operator double&()
    {
        return get_double();
    }
    operator const double&() const
    {
        return get_double();
    }

    int32_t&
    get_int32_t()
    {
        AssertSanity(Tint32_t);
        return (*(ptr_int32_t()));
    }
    const int32_t&
    get_int32_t() const
    {
        AssertSanity(Tint32_t);
        return (*(constptr_int32_t()));
    }
    operator int32_t&()
    {
        return get_int32_t();
    }
    operator const int32_t&() const
    {
        return get_int32_t();
    }

    UniquePtr<StructuredCloneData>&
    get_StructuredCloneData()
    {
        AssertSanity(TStructuredCloneData);
        return (*(ptr_StructuredCloneData()));
    }
    const UniquePtr<StructuredCloneData>&
    get_StructuredCloneData() const
    {
        AssertSanity(TStructuredCloneData);
        return (*(constptr_StructuredCloneData()));
    }
    operator UniquePtr<StructuredCloneData>&()
    {
        return get_StructuredCloneData();
    }
    operator const UniquePtr<StructuredCloneData>&() const
    {
        return get_StructuredCloneData();
    }

    UniquePtr<ClonedMessageData>&
    get_ClonedMessageData()
    {
        AssertSanity(TClonedMessageData);
        return (*(ptr_ClonedMessageData()));
    }
    const UniquePtr<ClonedMessageData>&
    get_ClonedMessageData() const
    {
        AssertSanity(TClonedMessageData);
        return (*(constptr_ClonedMessageData()));
    }
    operator UniquePtr<ClonedMessageData>&()
    {
        return get_ClonedMessageData();
    }
    operator const UniquePtr<ClonedMessageData>&() const
    {
        return get_ClonedMessageData();
    }

    mozilla::NotNull<RefPtr<nsIPrincipal>>&
    get_nsIPrincipal()
    {
        AssertSanity(TnsIPrincipal);
        return (*(ptr_nsIPrincipal()));
    }
    mozilla::NotNull<nsIPrincipal*>
    get_nsIPrincipal() const
    {
        AssertSanity(TnsIPrincipal);
        return (*(constptr_nsIPrincipal()));
    }
    operator mozilla::NotNull<RefPtr<nsIPrincipal>>&()
    {
        return get_nsIPrincipal();
    }
    operator mozilla::NotNull<nsIPrincipal*>() const
    {
        return get_nsIPrincipal();
    }

    MaybeDiscardedBrowsingContext&
    get_MaybeDiscardedBrowsingContext()
    {
        AssertSanity(TMaybeDiscardedBrowsingContext);
        return (*(ptr_MaybeDiscardedBrowsingContext()));
    }
    const MaybeDiscardedBrowsingContext&
    get_MaybeDiscardedBrowsingContext() const
    {
        AssertSanity(TMaybeDiscardedBrowsingContext);
        return (*(constptr_MaybeDiscardedBrowsingContext()));
    }
    operator MaybeDiscardedBrowsingContext&()
    {
        return get_MaybeDiscardedBrowsingContext();
    }
    operator const MaybeDiscardedBrowsingContext&() const
    {
        return get_MaybeDiscardedBrowsingContext();
    }

    JSIPCDOMRect&
    get_JSIPCDOMRect()
    {
        AssertSanity(TJSIPCDOMRect);
        return (*(ptr_JSIPCDOMRect()));
    }
    const JSIPCDOMRect&
    get_JSIPCDOMRect() const
    {
        AssertSanity(TJSIPCDOMRect);
        return (*(constptr_JSIPCDOMRect()));
    }
    operator JSIPCDOMRect&()
    {
        return get_JSIPCDOMRect();
    }
    operator const JSIPCDOMRect&() const
    {
        return get_JSIPCDOMRect();
    }

    nsTArray<JSIPCProperty>&
    get_ArrayOfJSIPCProperty()
    {
        AssertSanity(TArrayOfJSIPCProperty);
        return (*(ptr_ArrayOfJSIPCProperty()));
    }
    const nsTArray<JSIPCProperty>&
    get_ArrayOfJSIPCProperty() const
    {
        AssertSanity(TArrayOfJSIPCProperty);
        return (*(constptr_ArrayOfJSIPCProperty()));
    }
    operator nsTArray<JSIPCProperty>&()
    {
        return get_ArrayOfJSIPCProperty();
    }
    operator const nsTArray<JSIPCProperty>&() const
    {
        return get_ArrayOfJSIPCProperty();
    }

    JSIPCArray&
    get_JSIPCArray()
    {
        AssertSanity(TJSIPCArray);
        return (*(ptr_JSIPCArray()));
    }
    const JSIPCArray&
    get_JSIPCArray() const
    {
        AssertSanity(TJSIPCArray);
        return (*(constptr_JSIPCArray()));
    }
    operator JSIPCArray&()
    {
        return get_JSIPCArray();
    }
    operator const JSIPCArray&() const
    {
        return get_JSIPCArray();
    }

    JSIPCSet&
    get_JSIPCSet()
    {
        AssertSanity(TJSIPCSet);
        return (*(ptr_JSIPCSet()));
    }
    const JSIPCSet&
    get_JSIPCSet() const
    {
        AssertSanity(TJSIPCSet);
        return (*(constptr_JSIPCSet()));
    }
    operator JSIPCSet&()
    {
        return get_JSIPCSet();
    }
    operator const JSIPCSet&() const
    {
        return get_JSIPCSet();
    }

    nsTArray<JSIPCMapEntry>&
    get_ArrayOfJSIPCMapEntry()
    {
        AssertSanity(TArrayOfJSIPCMapEntry);
        return (*(ptr_ArrayOfJSIPCMapEntry()));
    }
    const nsTArray<JSIPCMapEntry>&
    get_ArrayOfJSIPCMapEntry() const
    {
        AssertSanity(TArrayOfJSIPCMapEntry);
        return (*(constptr_ArrayOfJSIPCMapEntry()));
    }
    operator nsTArray<JSIPCMapEntry>&()
    {
        return get_ArrayOfJSIPCMapEntry();
    }
    operator const nsTArray<JSIPCMapEntry>&() const
    {
        return get_ArrayOfJSIPCMapEntry();
    }

private:
    union {
        void_t mVvoid_t;
        null_t mVnull_t;
        nsString mVnsString;
        bool mVbool;
        double mVdouble;
        int32_t mVint32_t;
        UniquePtr<StructuredCloneData> mVStructuredCloneData;
        UniquePtr<ClonedMessageData> mVClonedMessageData;
        mozilla::NotNull<RefPtr<nsIPrincipal>> mVnsIPrincipal;
        MaybeDiscardedBrowsingContext mVMaybeDiscardedBrowsingContext;
        JSIPCDOMRect mVJSIPCDOMRect;
        nsTArray<JSIPCProperty>* mVArrayOfJSIPCProperty;
        JSIPCArray* mVJSIPCArray;
        JSIPCSet* mVJSIPCSet;
        nsTArray<JSIPCMapEntry>* mVArrayOfJSIPCMapEntry;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCValue>
{
    typedef ::mozilla::dom::JSIPCValue paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCProperty|
//
namespace mozilla {
namespace dom {
class JSIPCProperty final
{
private:
    typedef ::nsString nsString;
    typedef ::mozilla::dom::JSIPCValue JSIPCValue;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    JSIPCProperty() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT JSIPCProperty(
            const nsString& _name,
            JSIPCValue&& _value) :
        name_(_name),
        value_(std::move(_value))
    {
    }

    MOZ_IMPLICIT JSIPCProperty(
            nsString&& _name,
            JSIPCValue&& _value) :
        name_(std::move(_name)),
        value_(std::move(_value))
    {
    }

    nsString&
    name()
    {
        return name_;
    }
    const nsString&
    name() const
    {
        return name_;
    }

    JSIPCValue&
    value()
    {
        return value_;
    }
    const JSIPCValue&
    value() const
    {
        return value_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> name_;
    ::mozilla::ipc::IPDLStructMember<JSIPCValue> value_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCProperty>
{
    typedef ::mozilla::dom::JSIPCProperty paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCArray|
//
namespace mozilla {
namespace dom {
class JSIPCArray final
{
private:
    typedef ::mozilla::dom::JSIPCValue JSIPCValue;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    JSIPCArray() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT JSIPCArray(nsTArray<JSIPCValue>&& _elements) :
        elements_(std::move(_elements))
    {
    }

    nsTArray<JSIPCValue>&
    elements()
    {
        return elements_;
    }
    const nsTArray<JSIPCValue>&
    elements() const
    {
        return elements_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<JSIPCValue>> elements_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCArray>
{
    typedef ::mozilla::dom::JSIPCArray paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCSet|
//
namespace mozilla {
namespace dom {
class JSIPCSet final
{
private:
    typedef ::mozilla::dom::JSIPCValue JSIPCValue;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    JSIPCSet() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT JSIPCSet(nsTArray<JSIPCValue>&& _elements) :
        elements_(std::move(_elements))
    {
    }

    nsTArray<JSIPCValue>&
    elements()
    {
        return elements_;
    }
    const nsTArray<JSIPCValue>&
    elements() const
    {
        return elements_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<JSIPCValue>> elements_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCSet>
{
    typedef ::mozilla::dom::JSIPCSet paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSIPCMapEntry|
//
namespace mozilla {
namespace dom {
class JSIPCMapEntry final
{
private:
    typedef ::mozilla::dom::JSIPCValue JSIPCValue;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    JSIPCMapEntry() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT JSIPCMapEntry(
            JSIPCValue&& _key,
            JSIPCValue&& _value) :
        key_(std::move(_key)),
        value_(std::move(_value))
    {
    }

    JSIPCValue&
    key()
    {
        return key_;
    }
    const JSIPCValue&
    key() const
    {
        return key_;
    }

    JSIPCValue&
    value()
    {
        return value_;
    }
    const JSIPCValue&
    value() const
    {
        return value_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<JSIPCValue> key_;
    ::mozilla::ipc::IPDLStructMember<JSIPCValue> value_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::JSIPCMapEntry>
{
    typedef ::mozilla::dom::JSIPCMapEntry paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef JSIPCValue_h
