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


#include "mozilla/dom/IPCBlobUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/sessionstore/SessionStoreTypes.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Checkbox|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::Checkbox>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
}

auto ParamTraits<::mozilla::dom::sessionstore::Checkbox>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___value = IPC::ReadParam<bool>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (bool) member of 'Checkbox'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (bool) member of 'Checkbox'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_value)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TextField|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::TextField>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
}

auto ParamTraits<::mozilla::dom::sessionstore::TextField>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___value = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (nsString) member of 'TextField'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'TextField'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_value)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileList|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FileList>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).valueList());
    // Sentinel = 'valueList'
    (aWriter)->WriteSentinel(312935354);
}

auto ParamTraits<::mozilla::dom::sessionstore::FileList>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___valueList = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___valueList) {
        aReader->FatalError("Error deserializing 'valueList' (nsString[]) member of 'FileList'");
        return {};

    }
    auto& _valueList = *maybe___valueList;
    // Sentinel = 'valueList'
    if ((!((aReader)->ReadSentinel(312935354)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'valueList' (nsString[]) member of 'FileList'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_valueList)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SingleSelect|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::SingleSelect>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
    (aWriter)->WriteBytes((&((aVar).index())), 4);
    // Sentinel = 'index'
    (aWriter)->WriteSentinel(104333849);
}

auto ParamTraits<::mozilla::dom::sessionstore::SingleSelect>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___value = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (nsString) member of 'SingleSelect'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'SingleSelect'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            std::move(_value)};
    if ((!((aReader)->ReadBytesInto((&((result__)->index())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'index'
    if ((!((aReader)->ReadSentinel(104333849)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MultipleSelect|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::MultipleSelect>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).valueList());
    // Sentinel = 'valueList'
    (aWriter)->WriteSentinel(312935354);
}

auto ParamTraits<::mozilla::dom::sessionstore::MultipleSelect>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___valueList = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___valueList) {
        aReader->FatalError("Error deserializing 'valueList' (nsString[]) member of 'MultipleSelect'");
        return {};

    }
    auto& _valueList = *maybe___valueList;
    // Sentinel = 'valueList'
    if ((!((aReader)->ReadSentinel(312935354)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'valueList' (nsString[]) member of 'MultipleSelect'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_valueList)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FormEntryValue|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
auto FormEntryValue::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TCheckbox:
        {
            (ptr_Checkbox())->~Checkbox__tdef();
            break;
        }
    case TTextField:
        {
            (ptr_TextField())->~TextField__tdef();
            break;
        }
    case TFileList:
        {
            (ptr_FileList())->~FileList__tdef();
            break;
        }
    case TSingleSelect:
        {
            (ptr_SingleSelect())->~SingleSelect__tdef();
            break;
        }
    case TMultipleSelect:
        {
            (ptr_MultipleSelect())->~MultipleSelect__tdef();
            break;
        }
    case TCustomElementTuple:
        {
            (ptr_CustomElementTuple())->~CustomElementTuple__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const Checkbox& aOther)
{
    new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(aOther);
    mType = TCheckbox;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(Checkbox&& aOther)
{
    new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move(aOther));
    mType = TCheckbox;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const TextField& aOther)
{
    new (mozilla::KnownNotNull, ptr_TextField()) TextField(aOther);
    mType = TTextField;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(TextField&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move(aOther));
    mType = TTextField;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const FileList& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileList()) FileList(aOther);
    mType = TFileList;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(FileList&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move(aOther));
    mType = TFileList;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const SingleSelect& aOther)
{
    new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(aOther);
    mType = TSingleSelect;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(SingleSelect&& aOther)
{
    new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move(aOther));
    mType = TSingleSelect;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const MultipleSelect& aOther)
{
    new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(aOther);
    mType = TMultipleSelect;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(MultipleSelect&& aOther)
{
    new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move(aOther));
    mType = TMultipleSelect;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const CustomElementTuple& aOther)
{
    new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(aOther);
    mType = TCustomElementTuple;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(CustomElementTuple&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move(aOther));
    mType = TCustomElementTuple;
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(const FormEntryValue& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TCheckbox:
        {
            new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox((aOther).get_Checkbox());
            break;
        }
    case TTextField:
        {
            new (mozilla::KnownNotNull, ptr_TextField()) TextField((aOther).get_TextField());
            break;
        }
    case TFileList:
        {
            new (mozilla::KnownNotNull, ptr_FileList()) FileList((aOther).get_FileList());
            break;
        }
    case TSingleSelect:
        {
            new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect((aOther).get_SingleSelect());
            break;
        }
    case TMultipleSelect:
        {
            new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect((aOther).get_MultipleSelect());
            break;
        }
    case TCustomElementTuple:
        {
            new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple((aOther).get_CustomElementTuple());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FormEntryValue::FormEntryValue(FormEntryValue&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TCheckbox:
        {
            new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move((aOther).get_Checkbox()));
            (aOther).MaybeDestroy();
            break;
        }
    case TTextField:
        {
            new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move((aOther).get_TextField()));
            (aOther).MaybeDestroy();
            break;
        }
    case TFileList:
        {
            new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move((aOther).get_FileList()));
            (aOther).MaybeDestroy();
            break;
        }
    case TSingleSelect:
        {
            new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move((aOther).get_SingleSelect()));
            (aOther).MaybeDestroy();
            break;
        }
    case TMultipleSelect:
        {
            new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move((aOther).get_MultipleSelect()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCustomElementTuple:
        {
            new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move((aOther).get_CustomElementTuple()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

FormEntryValue::~FormEntryValue()
{
    MaybeDestroy();
}

auto FormEntryValue::operator=(const Checkbox& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(aRhs);
    mType = TCheckbox;
    return (*(this));
}

auto FormEntryValue::operator=(Checkbox&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move(aRhs));
    mType = TCheckbox;
    return (*(this));
}

auto FormEntryValue::operator=(const TextField& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_TextField()) TextField(aRhs);
    mType = TTextField;
    return (*(this));
}

auto FormEntryValue::operator=(TextField&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move(aRhs));
    mType = TTextField;
    return (*(this));
}

auto FormEntryValue::operator=(const FileList& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileList()) FileList(aRhs);
    mType = TFileList;
    return (*(this));
}

auto FormEntryValue::operator=(FileList&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move(aRhs));
    mType = TFileList;
    return (*(this));
}

auto FormEntryValue::operator=(const SingleSelect& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(aRhs);
    mType = TSingleSelect;
    return (*(this));
}

auto FormEntryValue::operator=(SingleSelect&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move(aRhs));
    mType = TSingleSelect;
    return (*(this));
}

auto FormEntryValue::operator=(const MultipleSelect& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(aRhs);
    mType = TMultipleSelect;
    return (*(this));
}

auto FormEntryValue::operator=(MultipleSelect&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move(aRhs));
    mType = TMultipleSelect;
    return (*(this));
}

auto FormEntryValue::operator=(const CustomElementTuple& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(aRhs);
    mType = TCustomElementTuple;
    return (*(this));
}

auto FormEntryValue::operator=(CustomElementTuple&& aRhs) -> FormEntryValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move(aRhs));
    mType = TCustomElementTuple;
    return (*(this));
}

auto FormEntryValue::operator=(const FormEntryValue& aRhs) -> FormEntryValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TCheckbox:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox((aRhs).get_Checkbox());
            break;
        }
    case TTextField:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_TextField()) TextField((aRhs).get_TextField());
            break;
        }
    case TFileList:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileList()) FileList((aRhs).get_FileList());
            break;
        }
    case TSingleSelect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect((aRhs).get_SingleSelect());
            break;
        }
    case TMultipleSelect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect((aRhs).get_MultipleSelect());
            break;
        }
    case TCustomElementTuple:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple((aRhs).get_CustomElementTuple());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FormEntryValue::operator=(FormEntryValue&& aRhs) -> FormEntryValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TCheckbox:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move((aRhs).get_Checkbox()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TTextField:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move((aRhs).get_TextField()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TFileList:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move((aRhs).get_FileList()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TSingleSelect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move((aRhs).get_SingleSelect()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TMultipleSelect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move((aRhs).get_MultipleSelect()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCustomElementTuple:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move((aRhs).get_CustomElementTuple()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormEntryValue>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::sessionstore::FormEntryValue union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'FormEntryValue'
    (aWriter)->WriteSentinel(695535012);

    switch (type) {
    case union__::TCheckbox:
        {
            IPC::WriteParam(aWriter, (aVar).get_Checkbox());
            // Sentinel = 'TCheckbox'
            (aWriter)->WriteSentinel(274858876);
            return;
        }
    case union__::TTextField:
        {
            IPC::WriteParam(aWriter, (aVar).get_TextField());
            // Sentinel = 'TTextField'
            (aWriter)->WriteSentinel(349897694);
            return;
        }
    case union__::TFileList:
        {
            IPC::WriteParam(aWriter, (aVar).get_FileList());
            // Sentinel = 'TFileList'
            (aWriter)->WriteSentinel(273810289);
            return;
        }
    case union__::TSingleSelect:
        {
            IPC::WriteParam(aWriter, (aVar).get_SingleSelect());
            // Sentinel = 'TSingleSelect'
            (aWriter)->WriteSentinel(583664919);
            return;
        }
    case union__::TMultipleSelect:
        {
            IPC::WriteParam(aWriter, (aVar).get_MultipleSelect());
            // Sentinel = 'TMultipleSelect'
            (aWriter)->WriteSentinel(794756609);
            return;
        }
    case union__::TCustomElementTuple:
        {
            IPC::WriteParam(aWriter, (aVar).get_CustomElementTuple());
            // Sentinel = 'TCustomElementTuple'
            (aWriter)->WriteSentinel(1257179044);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FormEntryValue");
            return;
        }
    }
}

auto ParamTraits<::mozilla::dom::sessionstore::FormEntryValue>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::dom::sessionstore::FormEntryValue union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union FormEntryValue");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'FormEntryValue'
    if ((!((aReader)->ReadSentinel(695535012)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union FormEntryValue");
        return {};
    }

    switch (type) {
    case union__::TCheckbox:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::Checkbox>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCheckbox of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCheckbox'
            if ((!((aReader)->ReadSentinel(274858876)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCheckbox of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TTextField:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::TextField>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TTextField of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TTextField'
            if ((!((aReader)->ReadSentinel(349897694)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TTextField of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TFileList:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::FileList>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TFileList of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TFileList'
            if ((!((aReader)->ReadSentinel(273810289)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileList of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TSingleSelect:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::SingleSelect>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TSingleSelect of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TSingleSelect'
            if ((!((aReader)->ReadSentinel(583664919)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TSingleSelect of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TMultipleSelect:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::MultipleSelect>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TMultipleSelect of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TMultipleSelect'
            if ((!((aReader)->ReadSentinel(794756609)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TMultipleSelect of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCustomElementTuple:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::CustomElementTuple>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCustomElementTuple of union FormEntryValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCustomElementTuple'
            if ((!((aReader)->ReadSentinel(1257179044)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCustomElementTuple of union FormEntryValue");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union FormEntryValue");
            return {};
        }
    }
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FormEntry|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormEntry>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).id());
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
}

auto ParamTraits<::mozilla::dom::sessionstore::FormEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___id = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___id) {
        aReader->FatalError("Error deserializing 'id' (nsString) member of 'FormEntry'");
        return {};

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'FormEntry'");
        return {};
    }
    auto maybe___value = IPC::ReadParam<::mozilla::dom::sessionstore::FormEntryValue>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (FormEntryValue) member of 'FormEntry'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (FormEntryValue) member of 'FormEntry'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_id),
            std::move(_value)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FormData|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).hasData());
    // Sentinel = 'hasData'
    (aWriter)->WriteSentinel(182452919);
    IPC::WriteParam(aWriter, (aVar).id());
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
    IPC::WriteParam(aWriter, (aVar).xpath());
    // Sentinel = 'xpath'
    (aWriter)->WriteSentinel(110101030);
    IPC::WriteParam(aWriter, (aVar).innerHTML());
    // Sentinel = 'innerHTML'
    (aWriter)->WriteSentinel(298189650);
    IPC::WriteParam(aWriter, (aVar).uri());
    // Sentinel = 'uri'
    (aWriter)->WriteSentinel(45023569);
}

auto ParamTraits<::mozilla::dom::sessionstore::FormData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___hasData = IPC::ReadParam<bool>(aReader);
    if (!maybe___hasData) {
        aReader->FatalError("Error deserializing 'hasData' (bool) member of 'FormData'");
        return {};

    }
    auto& _hasData = *maybe___hasData;
    // Sentinel = 'hasData'
    if ((!((aReader)->ReadSentinel(182452919)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasData' (bool) member of 'FormData'");
        return {};
    }
    auto maybe___id = IPC::ReadParam<nsTArray<::mozilla::dom::sessionstore::FormEntry>>(aReader);
    if (!maybe___id) {
        aReader->FatalError("Error deserializing 'id' (FormEntry[]) member of 'FormData'");
        return {};

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (FormEntry[]) member of 'FormData'");
        return {};
    }
    auto maybe___xpath = IPC::ReadParam<nsTArray<::mozilla::dom::sessionstore::FormEntry>>(aReader);
    if (!maybe___xpath) {
        aReader->FatalError("Error deserializing 'xpath' (FormEntry[]) member of 'FormData'");
        return {};

    }
    auto& _xpath = *maybe___xpath;
    // Sentinel = 'xpath'
    if ((!((aReader)->ReadSentinel(110101030)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'xpath' (FormEntry[]) member of 'FormData'");
        return {};
    }
    auto maybe___innerHTML = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___innerHTML) {
        aReader->FatalError("Error deserializing 'innerHTML' (nsString) member of 'FormData'");
        return {};

    }
    auto& _innerHTML = *maybe___innerHTML;
    // Sentinel = 'innerHTML'
    if ((!((aReader)->ReadSentinel(298189650)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'innerHTML' (nsString) member of 'FormData'");
        return {};
    }
    auto maybe___uri = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___uri) {
        aReader->FatalError("Error deserializing 'uri' (nsCString) member of 'FormData'");
        return {};

    }
    auto& _uri = *maybe___uri;
    // Sentinel = 'uri'
    if ((!((aReader)->ReadSentinel(45023569)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsCString) member of 'FormData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_hasData),
            std::move(_id),
            std::move(_xpath),
            std::move(_innerHTML),
            std::move(_uri)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocShellRestoreState|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::DocShellRestoreState>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).URI());
    // Sentinel = 'URI'
    (aWriter)->WriteSentinel(32440561);
    IPC::WriteParam(aWriter, (aVar).docShellCaps());
    // Sentinel = 'docShellCaps'
    (aWriter)->WriteSentinel(510854326);
}

auto ParamTraits<::mozilla::dom::sessionstore::DocShellRestoreState>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___URI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
    if (!maybe___URI) {
        aReader->FatalError("Error deserializing 'URI' (nsIURI) member of 'DocShellRestoreState'");
        return {};

    }
    auto& _URI = *maybe___URI;
    // Sentinel = 'URI'
    if ((!((aReader)->ReadSentinel(32440561)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'URI' (nsIURI) member of 'DocShellRestoreState'");
        return {};
    }
    auto maybe___docShellCaps = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___docShellCaps) {
        aReader->FatalError("Error deserializing 'docShellCaps' (nsCString) member of 'DocShellRestoreState'");
        return {};

    }
    auto& _docShellCaps = *maybe___docShellCaps;
    // Sentinel = 'docShellCaps'
    if ((!((aReader)->ReadSentinel(510854326)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'docShellCaps' (nsCString) member of 'DocShellRestoreState'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_URI),
            std::move(_docShellCaps)};
    return result__;
}

} // namespace IPC
