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


#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/DOMTypes.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 MessagePortIdentifier|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::MessagePortIdentifier>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).uuid());
    // Sentinel = 'uuid'
    (aWriter)->WriteSentinel(74252728);
    IPC::WriteParam(aWriter, (aVar).destinationUuid());
    // Sentinel = 'destinationUuid'
    (aWriter)->WriteSentinel(840435258);
    IPC::WriteParam(aWriter, (aVar).neutered());
    // Sentinel = 'neutered'
    (aWriter)->WriteSentinel(257229661);
    (aWriter)->WriteBytes((&((aVar).sequenceId())), 4);
    // Sentinel = 'sequenceId'
    (aWriter)->WriteSentinel(386204679);
}

auto ParamTraits<::mozilla::dom::MessagePortIdentifier>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___uuid = IPC::ReadParam<::nsID>(aReader);
    if (!maybe___uuid) {
        aReader->FatalError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
        return {};

    }
    auto& _uuid = *maybe___uuid;
    // Sentinel = 'uuid'
    if ((!((aReader)->ReadSentinel(74252728)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
        return {};
    }
    auto maybe___destinationUuid = IPC::ReadParam<::nsID>(aReader);
    if (!maybe___destinationUuid) {
        aReader->FatalError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
        return {};

    }
    auto& _destinationUuid = *maybe___destinationUuid;
    // Sentinel = 'destinationUuid'
    if ((!((aReader)->ReadSentinel(840435258)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
        return {};
    }
    auto maybe___neutered = IPC::ReadParam<bool>(aReader);
    if (!maybe___neutered) {
        aReader->FatalError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
        return {};

    }
    auto& _neutered = *maybe___neutered;
    // Sentinel = 'neutered'
    if ((!((aReader)->ReadSentinel(257229661)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_uuid),
            std::move(_destinationUuid),
            ::uint32_t{0},
            std::move(_neutered)};
    if ((!((aReader)->ReadBytesInto((&((result__)->sequenceId())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'sequenceId'
    if ((!((aReader)->ReadSentinel(386204679)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ClonedMessageData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    IPC::WriteParam(aWriter, (aVar).blobs());
    // Sentinel = 'blobs'
    (aWriter)->WriteSentinel(102957587);
    IPC::WriteParam(aWriter, (aVar).inputStreams());
    // Sentinel = 'inputStreams'
    (aWriter)->WriteSentinel(554304784);
    IPC::WriteParam(aWriter, (aVar).identifiers());
    // Sentinel = 'identifiers'
    (aWriter)->WriteSentinel(456983703);
}

auto ParamTraits<::mozilla::dom::ClonedMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___data = IPC::ReadParam<::mozilla::SerializedStructuredCloneBuffer>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
        return {};
    }
    auto maybe___blobs = IPC::ReadParam<nsTArray<::mozilla::dom::IPCBlob>>(aReader);
    if (!maybe___blobs) {
        aReader->FatalError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
        return {};

    }
    auto& _blobs = *maybe___blobs;
    // Sentinel = 'blobs'
    if ((!((aReader)->ReadSentinel(102957587)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
        return {};
    }
    auto maybe___inputStreams = IPC::ReadParam<nsTArray<::mozilla::ipc::IPCStream>>(aReader);
    if (!maybe___inputStreams) {
        aReader->FatalError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
        return {};

    }
    auto& _inputStreams = *maybe___inputStreams;
    // Sentinel = 'inputStreams'
    if ((!((aReader)->ReadSentinel(554304784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
        return {};
    }
    auto maybe___identifiers = IPC::ReadParam<nsTArray<::mozilla::dom::MessagePortIdentifier>>(aReader);
    if (!maybe___identifiers) {
        aReader->FatalError("Error deserializing 'identifiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
        return {};

    }
    auto& _identifiers = *maybe___identifiers;
    // Sentinel = 'identifiers'
    if ((!((aReader)->ReadSentinel(456983703)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'identifiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_data),
            std::move(_blobs),
            std::move(_inputStreams),
            std::move(_identifiers)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ErrorMessageData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
}

auto ParamTraits<::mozilla::dom::ErrorMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    IPC::ReadResult<paramType> result__{std::in_place};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ClonedOrErrorMessageData|
//
namespace mozilla {
namespace dom {
auto ClonedOrErrorMessageData::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TClonedMessageData:
        {
            (ptr_ClonedMessageData())->~ClonedMessageData__tdef();
            break;
        }
    case TErrorMessageData:
        {
            (ptr_ErrorMessageData())->~ErrorMessageData__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ClonedMessageData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aOther));
    mType = TClonedMessageData;
}

MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(const ErrorMessageData& aOther)
{
    new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(aOther);
    mType = TErrorMessageData;
}

MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ErrorMessageData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move(aOther));
    mType = TErrorMessageData;
}

MOZ_IMPLICIT ClonedOrErrorMessageData::ClonedOrErrorMessageData(ClonedOrErrorMessageData&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TClonedMessageData:
        {
            new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aOther).get_ClonedMessageData()));
            (aOther).MaybeDestroy();
            break;
        }
    case TErrorMessageData:
        {
            new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move((aOther).get_ErrorMessageData()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ClonedOrErrorMessageData::operator=(ClonedMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aRhs));
    mType = TClonedMessageData;
    return (*(this));
}

auto ClonedOrErrorMessageData::operator=(const ErrorMessageData& aRhs) -> ClonedOrErrorMessageData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(aRhs);
    mType = TErrorMessageData;
    return (*(this));
}

auto ClonedOrErrorMessageData::operator=(ErrorMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move(aRhs));
    mType = TErrorMessageData;
    return (*(this));
}

auto ClonedOrErrorMessageData::operator=(ClonedOrErrorMessageData&& aRhs) -> ClonedOrErrorMessageData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TClonedMessageData:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aRhs).get_ClonedMessageData()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TErrorMessageData:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ErrorMessageData()) ErrorMessageData(std::move((aRhs).get_ErrorMessageData()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TClonedMessageData:
        {
            IPC::WriteParam(aWriter, (aVar).get_ClonedMessageData());
            // Sentinel = 'TClonedMessageData'
            (aWriter)->WriteSentinel(1089275625);
            return;
        }
    case union__::TErrorMessageData:
        {
            IPC::WriteParam(aWriter, (aVar).get_ErrorMessageData());
            // Sentinel = 'TErrorMessageData'
            (aWriter)->WriteSentinel(994313886);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ClonedOrErrorMessageData");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::RefMessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___uuid = IPC::ReadParam<::nsID>(aReader);
    if (!maybe___uuid) {
        aReader->FatalError("Error deserializing 'uuid' (nsID) member of 'RefMessageData'");
        return {};

    }
    auto& _uuid = *maybe___uuid;
    // Sentinel = 'uuid'
    if ((!((aReader)->ReadSentinel(74252728)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'RefMessageData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_uuid)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union MessageDataType|
//
namespace mozilla {
namespace dom {
auto MessageDataType::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TClonedMessageData:
        {
            (ptr_ClonedMessageData())->~ClonedMessageData__tdef();
            break;
        }
    case TRefMessageData:
        {
            (ptr_RefMessageData())->~RefMessageData__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT MessageDataType::MessageDataType(ClonedMessageData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aOther));
    mType = TClonedMessageData;
}

MOZ_IMPLICIT MessageDataType::MessageDataType(const RefMessageData& aOther)
{
    new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(aOther);
    mType = TRefMessageData;
}

MOZ_IMPLICIT MessageDataType::MessageDataType(RefMessageData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move(aOther));
    mType = TRefMessageData;
}

MOZ_IMPLICIT MessageDataType::MessageDataType(MessageDataType&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TClonedMessageData:
        {
            new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aOther).get_ClonedMessageData()));
            (aOther).MaybeDestroy();
            break;
        }
    case TRefMessageData:
        {
            new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move((aOther).get_RefMessageData()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto MessageDataType::operator=(ClonedMessageData&& aRhs) -> MessageDataType&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move(aRhs));
    mType = TClonedMessageData;
    return (*(this));
}

auto MessageDataType::operator=(const RefMessageData& aRhs) -> MessageDataType&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(aRhs);
    mType = TRefMessageData;
    return (*(this));
}

auto MessageDataType::operator=(RefMessageData&& aRhs) -> MessageDataType&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move(aRhs));
    mType = TRefMessageData;
    return (*(this));
}

auto MessageDataType::operator=(MessageDataType&& aRhs) -> MessageDataType&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TClonedMessageData:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ClonedMessageData()) ClonedMessageData(std::move((aRhs).get_ClonedMessageData()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TRefMessageData:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_RefMessageData()) RefMessageData(std::move((aRhs).get_RefMessageData()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TClonedMessageData:
        {
            IPC::WriteParam(aWriter, (aVar).get_ClonedMessageData());
            // Sentinel = 'TClonedMessageData'
            (aWriter)->WriteSentinel(1089275625);
            return;
        }
    case union__::TRefMessageData:
        {
            IPC::WriteParam(aWriter, (aVar).get_RefMessageData());
            // Sentinel = 'TRefMessageData'
            (aWriter)->WriteSentinel(751437233);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union MessageDataType");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::MessageData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).agentClusterId());
    // Sentinel = 'agentClusterId'
    (aWriter)->WriteSentinel(710477215);
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
}

auto ParamTraits<::mozilla::dom::MessageData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___agentClusterId = IPC::ReadParam<mozilla::Maybe<::nsID>>(aReader);
    if (!maybe___agentClusterId) {
        aReader->FatalError("Error deserializing 'agentClusterId' (nsID?) member of 'MessageData'");
        return {};

    }
    auto& _agentClusterId = *maybe___agentClusterId;
    // Sentinel = 'agentClusterId'
    if ((!((aReader)->ReadSentinel(710477215)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'agentClusterId' (nsID?) member of 'MessageData'");
        return {};
    }
    auto maybe___data = IPC::ReadParam<::mozilla::dom::MessageDataType>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (MessageDataType) member of 'MessageData'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (MessageDataType) member of 'MessageData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_agentClusterId),
            std::move(_data)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ScreenDetails|
//
namespace mozilla {
namespace dom {
auto ScreenDetails::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(ScreenDetails, dpi_) - offsetof(ScreenDetails, pixelDepth_)) == 12,
        "Bad assumptions about field layout!");
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::ScreenDetails>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).rect());
    // Sentinel = 'rect'
    (aWriter)->WriteSentinel(70582703);
    IPC::WriteParam(aWriter, (aVar).rectDisplayPix());
    // Sentinel = 'rectDisplayPix'
    (aWriter)->WriteSentinel(714540470);
    IPC::WriteParam(aWriter, (aVar).availRect());
    // Sentinel = 'availRect'
    (aWriter)->WriteSentinel(302777244);
    IPC::WriteParam(aWriter, (aVar).availRectDisplayPix());
    // Sentinel = 'availRectDisplayPix'
    (aWriter)->WriteSentinel(1269827491);
    IPC::WriteParam(aWriter, (aVar).contentsScaleFactor());
    // Sentinel = 'contentsScaleFactor'
    (aWriter)->WriteSentinel(1304102838);
    IPC::WriteParam(aWriter, (aVar).defaultCSSScaleFactor());
    // Sentinel = 'defaultCSSScaleFactor'
    (aWriter)->WriteSentinel(1482885142);
    IPC::WriteParam(aWriter, (aVar).orientation());
    // Sentinel = 'orientation'
    (aWriter)->WriteSentinel(471008429);
    IPC::WriteParam(aWriter, (aVar).isPseudoDisplay());
    // Sentinel = 'isPseudoDisplay'
    (aWriter)->WriteSentinel(816383523);
    IPC::WriteParam(aWriter, (aVar).isHDR());
    // Sentinel = 'isHDR'
    (aWriter)->WriteSentinel(93323707);
    (aWriter)->WriteBytes((&((aVar).pixelDepth())), 16);
    // Sentinel = 'pixelDepth | colorDepth | refreshRate | dpi'
    (aWriter)->WriteSentinel(1735462936);
    (aWriter)->WriteBytes((&((aVar).orientationAngle())), 2);
    // Sentinel = 'orientationAngle'
    (aWriter)->WriteSentinel(954402452);
}

auto ParamTraits<::mozilla::dom::ScreenDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___rect = IPC::ReadParam<::mozilla::LayoutDeviceIntRect>(aReader);
    if (!maybe___rect) {
        aReader->FatalError("Error deserializing 'rect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
        return {};

    }
    auto& _rect = *maybe___rect;
    // Sentinel = 'rect'
    if ((!((aReader)->ReadSentinel(70582703)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___rectDisplayPix = IPC::ReadParam<::mozilla::DesktopIntRect>(aReader);
    if (!maybe___rectDisplayPix) {
        aReader->FatalError("Error deserializing 'rectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
        return {};

    }
    auto& _rectDisplayPix = *maybe___rectDisplayPix;
    // Sentinel = 'rectDisplayPix'
    if ((!((aReader)->ReadSentinel(714540470)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___availRect = IPC::ReadParam<::mozilla::LayoutDeviceIntRect>(aReader);
    if (!maybe___availRect) {
        aReader->FatalError("Error deserializing 'availRect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
        return {};

    }
    auto& _availRect = *maybe___availRect;
    // Sentinel = 'availRect'
    if ((!((aReader)->ReadSentinel(302777244)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'availRect' (LayoutDeviceIntRect) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___availRectDisplayPix = IPC::ReadParam<::mozilla::DesktopIntRect>(aReader);
    if (!maybe___availRectDisplayPix) {
        aReader->FatalError("Error deserializing 'availRectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
        return {};

    }
    auto& _availRectDisplayPix = *maybe___availRectDisplayPix;
    // Sentinel = 'availRectDisplayPix'
    if ((!((aReader)->ReadSentinel(1269827491)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'availRectDisplayPix' (DesktopIntRect) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___contentsScaleFactor = IPC::ReadParam<::mozilla::DesktopToLayoutDeviceScale>(aReader);
    if (!maybe___contentsScaleFactor) {
        aReader->FatalError("Error deserializing 'contentsScaleFactor' (DesktopToLayoutDeviceScale) member of 'ScreenDetails'");
        return {};

    }
    auto& _contentsScaleFactor = *maybe___contentsScaleFactor;
    // Sentinel = 'contentsScaleFactor'
    if ((!((aReader)->ReadSentinel(1304102838)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentsScaleFactor' (DesktopToLayoutDeviceScale) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___defaultCSSScaleFactor = IPC::ReadParam<::mozilla::CSSToLayoutDeviceScale>(aReader);
    if (!maybe___defaultCSSScaleFactor) {
        aReader->FatalError("Error deserializing 'defaultCSSScaleFactor' (CSSToLayoutDeviceScale) member of 'ScreenDetails'");
        return {};

    }
    auto& _defaultCSSScaleFactor = *maybe___defaultCSSScaleFactor;
    // Sentinel = 'defaultCSSScaleFactor'
    if ((!((aReader)->ReadSentinel(1482885142)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'defaultCSSScaleFactor' (CSSToLayoutDeviceScale) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___orientation = IPC::ReadParam<::mozilla::hal::ScreenOrientation>(aReader);
    if (!maybe___orientation) {
        aReader->FatalError("Error deserializing 'orientation' (ScreenOrientation) member of 'ScreenDetails'");
        return {};

    }
    auto& _orientation = *maybe___orientation;
    // Sentinel = 'orientation'
    if ((!((aReader)->ReadSentinel(471008429)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'orientation' (ScreenOrientation) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___isPseudoDisplay = IPC::ReadParam<bool>(aReader);
    if (!maybe___isPseudoDisplay) {
        aReader->FatalError("Error deserializing 'isPseudoDisplay' (bool) member of 'ScreenDetails'");
        return {};

    }
    auto& _isPseudoDisplay = *maybe___isPseudoDisplay;
    // Sentinel = 'isPseudoDisplay'
    if ((!((aReader)->ReadSentinel(816383523)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isPseudoDisplay' (bool) member of 'ScreenDetails'");
        return {};
    }
    auto maybe___isHDR = IPC::ReadParam<bool>(aReader);
    if (!maybe___isHDR) {
        aReader->FatalError("Error deserializing 'isHDR' (bool) member of 'ScreenDetails'");
        return {};

    }
    auto& _isHDR = *maybe___isHDR;
    // Sentinel = 'isHDR'
    if ((!((aReader)->ReadSentinel(93323707)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isHDR' (bool) member of 'ScreenDetails'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rect),
            std::move(_rectDisplayPix),
            std::move(_availRect),
            std::move(_availRectDisplayPix),
            ::int32_t{0},
            ::int32_t{0},
            ::uint32_t{0},
            std::move(_contentsScaleFactor),
            std::move(_defaultCSSScaleFactor),
            float{0},
            std::move(_orientation),
            ::uint16_t{0},
            std::move(_isPseudoDisplay),
            std::move(_isHDR)};
    if ((!((aReader)->ReadBytesInto((&((result__)->pixelDepth())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int32_t");
        return {};
    }
    // Sentinel = 'pixelDepth | colorDepth | refreshRate | dpi'
    if ((!((aReader)->ReadSentinel(1735462936)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->orientationAngle())), 2)))) {
        aReader->FatalError("Error bulk reading fields from uint16_t");
        return {};
    }
    // Sentinel = 'orientationAngle'
    if ((!((aReader)->ReadSentinel(954402452)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::DimensionInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).rect());
    // Sentinel = 'rect'
    (aWriter)->WriteSentinel(70582703);
    IPC::WriteParam(aWriter, (aVar).size());
    // Sentinel = 'size'
    (aWriter)->WriteSentinel(73662908);
    IPC::WriteParam(aWriter, (aVar).clientOffset());
    // Sentinel = 'clientOffset'
    (aWriter)->WriteSentinel(530449639);
    IPC::WriteParam(aWriter, (aVar).chromeOffset());
    // Sentinel = 'chromeOffset'
    (aWriter)->WriteSentinel(531956966);
}

auto ParamTraits<::mozilla::dom::DimensionInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___rect = IPC::ReadParam<::mozilla::CSSRect>(aReader);
    if (!maybe___rect) {
        aReader->FatalError("Error deserializing 'rect' (CSSRect) member of 'DimensionInfo'");
        return {};

    }
    auto& _rect = *maybe___rect;
    // Sentinel = 'rect'
    if ((!((aReader)->ReadSentinel(70582703)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rect' (CSSRect) member of 'DimensionInfo'");
        return {};
    }
    auto maybe___size = IPC::ReadParam<::mozilla::CSSSize>(aReader);
    if (!maybe___size) {
        aReader->FatalError("Error deserializing 'size' (CSSSize) member of 'DimensionInfo'");
        return {};

    }
    auto& _size = *maybe___size;
    // Sentinel = 'size'
    if ((!((aReader)->ReadSentinel(73662908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (CSSSize) member of 'DimensionInfo'");
        return {};
    }
    auto maybe___clientOffset = IPC::ReadParam<::mozilla::LayoutDeviceIntPoint>(aReader);
    if (!maybe___clientOffset) {
        aReader->FatalError("Error deserializing 'clientOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
        return {};

    }
    auto& _clientOffset = *maybe___clientOffset;
    // Sentinel = 'clientOffset'
    if ((!((aReader)->ReadSentinel(530449639)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clientOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
        return {};
    }
    auto maybe___chromeOffset = IPC::ReadParam<::mozilla::LayoutDeviceIntPoint>(aReader);
    if (!maybe___chromeOffset) {
        aReader->FatalError("Error deserializing 'chromeOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
        return {};

    }
    auto& _chromeOffset = *maybe___chromeOffset;
    // Sentinel = 'chromeOffset'
    if ((!((aReader)->ReadSentinel(531956966)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'chromeOffset' (LayoutDeviceIntPoint) member of 'DimensionInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rect),
            std::move(_size),
            std::move(_clientOffset),
            std::move(_chromeOffset)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::FrameScriptInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).url());
    // Sentinel = 'url'
    (aWriter)->WriteSentinel(45220180);
    IPC::WriteParam(aWriter, (aVar).runInGlobalScope());
    // Sentinel = 'runInGlobalScope'
    (aWriter)->WriteSentinel(907282008);
}

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

    }
    auto& _url = *maybe___url;
    // Sentinel = 'url'
    if ((!((aReader)->ReadSentinel(45220180)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'url' (nsString) member of 'FrameScriptInfo'");
        return {};
    }
    auto maybe___runInGlobalScope = IPC::ReadParam<bool>(aReader);
    if (!maybe___runInGlobalScope) {
        aReader->FatalError("Error deserializing 'runInGlobalScope' (bool) member of 'FrameScriptInfo'");
        return {};

    }
    auto& _runInGlobalScope = *maybe___runInGlobalScope;
    // Sentinel = 'runInGlobalScope'
    if ((!((aReader)->ReadSentinel(907282008)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'runInGlobalScope' (bool) member of 'FrameScriptInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_url),
            std::move(_runInGlobalScope)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::CreatedWindowInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).rv());
    // Sentinel = 'rv'
    (aWriter)->WriteSentinel(22806761);
    IPC::WriteParam(aWriter, (aVar).windowOpened());
    // Sentinel = 'windowOpened'
    (aWriter)->WriteSentinel(549586164);
    IPC::WriteParam(aWriter, (aVar).frameScripts());
    // Sentinel = 'frameScripts'
    (aWriter)->WriteSentinel(530646260);
    IPC::WriteParam(aWriter, (aVar).dimensions());
    // Sentinel = 'dimensions'
    (aWriter)->WriteSentinel(383845434);
    (aWriter)->WriteBytes((&((aVar).maxTouchPoints())), 4);
    // Sentinel = 'maxTouchPoints'
    (aWriter)->WriteSentinel(719586759);
}

auto ParamTraits<::mozilla::dom::CreatedWindowInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___rv = IPC::ReadParam<::nsresult>(aReader);
    if (!maybe___rv) {
        aReader->FatalError("Error deserializing 'rv' (nsresult) member of 'CreatedWindowInfo'");
        return {};

    }
    auto& _rv = *maybe___rv;
    // Sentinel = 'rv'
    if ((!((aReader)->ReadSentinel(22806761)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rv' (nsresult) member of 'CreatedWindowInfo'");
        return {};
    }
    auto maybe___windowOpened = IPC::ReadParam<bool>(aReader);
    if (!maybe___windowOpened) {
        aReader->FatalError("Error deserializing 'windowOpened' (bool) member of 'CreatedWindowInfo'");
        return {};

    }
    auto& _windowOpened = *maybe___windowOpened;
    // Sentinel = 'windowOpened'
    if ((!((aReader)->ReadSentinel(549586164)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'windowOpened' (bool) member of 'CreatedWindowInfo'");
        return {};
    }
    auto maybe___frameScripts = IPC::ReadParam<nsTArray<::mozilla::dom::FrameScriptInfo>>(aReader);
    if (!maybe___frameScripts) {
        aReader->FatalError("Error deserializing 'frameScripts' (FrameScriptInfo[]) member of 'CreatedWindowInfo'");
        return {};

    }
    auto& _frameScripts = *maybe___frameScripts;
    // Sentinel = 'frameScripts'
    if ((!((aReader)->ReadSentinel(530646260)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'frameScripts' (FrameScriptInfo[]) member of 'CreatedWindowInfo'");
        return {};
    }
    auto maybe___dimensions = IPC::ReadParam<::mozilla::dom::DimensionInfo>(aReader);
    if (!maybe___dimensions) {
        aReader->FatalError("Error deserializing 'dimensions' (DimensionInfo) member of 'CreatedWindowInfo'");
        return {};

    }
    auto& _dimensions = *maybe___dimensions;
    // Sentinel = 'dimensions'
    if ((!((aReader)->ReadSentinel(383845434)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dimensions' (DimensionInfo) member of 'CreatedWindowInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rv),
            std::move(_windowOpened),
            std::move(_frameScripts),
            ::uint32_t{0},
            std::move(_dimensions)};
    if ((!((aReader)->ReadBytesInto((&((result__)->maxTouchPoints())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'maxTouchPoints'
    if ((!((aReader)->ReadSentinel(719586759)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocShellLoadStateInit|
//
namespace mozilla {
namespace dom {
auto DocShellLoadStateInit::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(DocShellLoadStateInit, TriggeringWindowId_) - offsetof(DocShellLoadStateInit, LoadIdentifier_)) == 8,
        "Bad assumptions about field layout!");
    static_assert(
        (offsetof(DocShellLoadStateInit, TriggeringSandboxFlags_) - offsetof(DocShellLoadStateInit, LoadType_)) == 12,
        "Bad assumptions about field layout!");
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::DocShellLoadStateInit>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).URI());
    // Sentinel = 'URI'
    (aWriter)->WriteSentinel(32440561);
    IPC::WriteParam(aWriter, (aVar).OriginalURI());
    // Sentinel = 'OriginalURI'
    (aWriter)->WriteSentinel(432079910);
    IPC::WriteParam(aWriter, (aVar).ResultPrincipalURI());
    // Sentinel = 'ResultPrincipalURI'
    (aWriter)->WriteSentinel(1159202578);
    IPC::WriteParam(aWriter, (aVar).TriggeringPrincipal());
    // Sentinel = 'TriggeringPrincipal'
    (aWriter)->WriteSentinel(1285883829);
    IPC::WriteParam(aWriter, (aVar).ReferrerInfo());
    // Sentinel = 'ReferrerInfo'
    (aWriter)->WriteSentinel(515048650);
    IPC::WriteParam(aWriter, (aVar).PrincipalToInherit());
    // Sentinel = 'PrincipalToInherit'
    (aWriter)->WriteSentinel(1138689849);
    IPC::WriteParam(aWriter, (aVar).PartitionedPrincipalToInherit());
    // Sentinel = 'PartitionedPrincipalToInherit'
    (aWriter)->WriteSentinel(2949909436);
    IPC::WriteParam(aWriter, (aVar).BaseURI());
    // Sentinel = 'BaseURI'
    (aWriter)->WriteSentinel(165282412);
    IPC::WriteParam(aWriter, (aVar).PolicyContainer());
    // Sentinel = 'PolicyContainer'
    (aWriter)->WriteSentinel(802162196);
    IPC::WriteParam(aWriter, (aVar).PostDataStream());
    // Sentinel = 'PostDataStream'
    (aWriter)->WriteSentinel(690292109);
    IPC::WriteParam(aWriter, (aVar).HeadersStream());
    // Sentinel = 'HeadersStream'
    (aWriter)->WriteSentinel(589432105);
    IPC::WriteParam(aWriter, (aVar).UnstrippedURI());
    // Sentinel = 'UnstrippedURI'
    (aWriter)->WriteSentinel(627967263);
    IPC::WriteParam(aWriter, (aVar).Target());
    // Sentinel = 'Target'
    (aWriter)->WriteSentinel(136184424);
    IPC::WriteParam(aWriter, (aVar).TypeHint());
    // Sentinel = 'TypeHint'
    (aWriter)->WriteSentinel(238748470);
    IPC::WriteParam(aWriter, (aVar).FileName());
    // Sentinel = 'FileName'
    (aWriter)->WriteSentinel(221381378);
    IPC::WriteParam(aWriter, (aVar).SourceBrowsingContext());
    // Sentinel = 'SourceBrowsingContext'
    (aWriter)->WriteSentinel(1569720482);
    IPC::WriteParam(aWriter, (aVar).TargetBrowsingContext());
    // Sentinel = 'TargetBrowsingContext'
    (aWriter)->WriteSentinel(1553991832);
    IPC::WriteParam(aWriter, (aVar).TriggeringRemoteType());
    // Sentinel = 'TriggeringRemoteType'
    (aWriter)->WriteSentinel(1421281313);
    IPC::WriteParam(aWriter, (aVar).SrcdocData());
    // Sentinel = 'SrcdocData'
    (aWriter)->WriteSentinel(354616281);
    IPC::WriteParam(aWriter, (aVar).OriginalURIString());
    // Sentinel = 'OriginalURIString'
    (aWriter)->WriteSentinel(992020125);
    IPC::WriteParam(aWriter, (aVar).RemoteTypeOverride());
    // Sentinel = 'RemoteTypeOverride'
    (aWriter)->WriteSentinel(1155467087);
    IPC::WriteParam(aWriter, (aVar).loadingSessionHistoryInfo());
    // Sentinel = 'loadingSessionHistoryInfo'
    (aWriter)->WriteSentinel(2228161089);
    IPC::WriteParam(aWriter, (aVar).userNavigationInvolvement());
    // Sentinel = 'userNavigationInvolvement'
    (aWriter)->WriteSentinel(2256013927);
    IPC::WriteParam(aWriter, (aVar).TriggeringStorageAccess());
    // Sentinel = 'TriggeringStorageAccess'
    (aWriter)->WriteSentinel(1859782970);
    IPC::WriteParam(aWriter, (aVar).TriggeringClassificationFlags());
    // Sentinel = 'TriggeringClassificationFlags'
    (aWriter)->WriteSentinel(2931559340);
    IPC::WriteParam(aWriter, (aVar).CancelContentJSEpoch());
    // Sentinel = 'CancelContentJSEpoch'
    (aWriter)->WriteSentinel(1340278702);
    IPC::WriteParam(aWriter, (aVar).ResultPrincipalURIIsSome());
    // Sentinel = 'ResultPrincipalURIIsSome'
    (aWriter)->WriteSentinel(2001799522);
    IPC::WriteParam(aWriter, (aVar).KeepResultPrincipalURIIfSet());
    // Sentinel = 'KeepResultPrincipalURIIfSet'
    (aWriter)->WriteSentinel(2486831730);
    IPC::WriteParam(aWriter, (aVar).LoadReplace());
    // Sentinel = 'LoadReplace'
    (aWriter)->WriteSentinel(418907197);
    IPC::WriteParam(aWriter, (aVar).InheritPrincipal());
    // Sentinel = 'InheritPrincipal'
    (aWriter)->WriteSentinel(908723830);
    IPC::WriteParam(aWriter, (aVar).PrincipalIsExplicit());
    // Sentinel = 'PrincipalIsExplicit'
    (aWriter)->WriteSentinel(1265567649);
    IPC::WriteParam(aWriter, (aVar).NotifiedBeforeUnloadListeners());
    // Sentinel = 'NotifiedBeforeUnloadListeners'
    (aWriter)->WriteSentinel(2882538402);
    IPC::WriteParam(aWriter, (aVar).ForceAllowDataURI());
    // Sentinel = 'ForceAllowDataURI'
    (aWriter)->WriteSentinel(977077849);
    IPC::WriteParam(aWriter, (aVar).IsExemptFromHTTPSFirstMode());
    // Sentinel = 'IsExemptFromHTTPSFirstMode'
    (aWriter)->WriteSentinel(2233272804);
    IPC::WriteParam(aWriter, (aVar).OriginalFrameSrc());
    // Sentinel = 'OriginalFrameSrc'
    (aWriter)->WriteSentinel(896271945);
    IPC::WriteParam(aWriter, (aVar).ShouldCheckForRecursion());
    // Sentinel = 'ShouldCheckForRecursion'
    (aWriter)->WriteSentinel(1812531503);
    IPC::WriteParam(aWriter, (aVar).IsFormSubmission());
    // Sentinel = 'IsFormSubmission'
    (aWriter)->WriteSentinel(893978237);
    IPC::WriteParam(aWriter, (aVar).FirstParty());
    // Sentinel = 'FirstParty'
    (aWriter)->WriteSentinel(363791385);
    IPC::WriteParam(aWriter, (aVar).HasValidUserGestureActivation());
    // Sentinel = 'HasValidUserGestureActivation'
    (aWriter)->WriteSentinel(2853571485);
    IPC::WriteParam(aWriter, (aVar).TextDirectiveUserActivation());
    // Sentinel = 'TextDirectiveUserActivation'
    (aWriter)->WriteSentinel(2543389430);
    IPC::WriteParam(aWriter, (aVar).AllowFocusMove());
    // Sentinel = 'AllowFocusMove'
    (aWriter)->WriteSentinel(688194967);
    IPC::WriteParam(aWriter, (aVar).IsFromProcessingFrameAttributes());
    // Sentinel = 'IsFromProcessingFrameAttributes'
    (aWriter)->WriteSentinel(3294956672);
    IPC::WriteParam(aWriter, (aVar).NeedsCompletelyLoadedDocument());
    // Sentinel = 'NeedsCompletelyLoadedDocument'
    (aWriter)->WriteSentinel(2878016406);
    IPC::WriteParam(aWriter, (aVar).ShouldNotForceReplaceInOnLoad());
    // Sentinel = 'ShouldNotForceReplaceInOnLoad'
    (aWriter)->WriteSentinel(2863270720);
    IPC::WriteParam(aWriter, (aVar).HistoryBehavior());
    // Sentinel = 'HistoryBehavior'
    (aWriter)->WriteSentinel(810616355);
    IPC::WriteParam(aWriter, (aVar).SchemelessInput());
    // Sentinel = 'SchemelessInput'
    (aWriter)->WriteSentinel(798557725);
    IPC::WriteParam(aWriter, (aVar).forceMediaDocument());
    // Sentinel = 'forceMediaDocument'
    (aWriter)->WriteSentinel(1132136239);
    IPC::WriteParam(aWriter, (aVar).HttpsUpgradeTelemetry());
    // Sentinel = 'HttpsUpgradeTelemetry'
    (aWriter)->WriteSentinel(1562249367);
    IPC::WriteParam(aWriter, (aVar).NavigationAPIState());
    // Sentinel = 'NavigationAPIState'
    (aWriter)->WriteSentinel(1107887852);
    IPC::WriteParam(aWriter, (aVar).ChannelInitialized());
    // Sentinel = 'ChannelInitialized'
    (aWriter)->WriteSentinel(1118308144);
    IPC::WriteParam(aWriter, (aVar).TryToReplaceWithSessionHistoryLoad());
    // Sentinel = 'TryToReplaceWithSessionHistoryLoad'
    (aWriter)->WriteSentinel(3987606961);
    IPC::WriteParam(aWriter, (aVar).IsMetaRefresh());
    // Sentinel = 'IsMetaRefresh'
    (aWriter)->WriteSentinel(576849171);
    IPC::WriteParam(aWriter, (aVar).IsCaptivePortalTab());
    // Sentinel = 'IsCaptivePortalTab'
    (aWriter)->WriteSentinel(1115490066);
    (aWriter)->WriteBytes((&((aVar).LoadIdentifier())), 16);
    // Sentinel = 'LoadIdentifier | TriggeringWindowId'
    (aWriter)->WriteSentinel(4016246135);
    (aWriter)->WriteBytes((&((aVar).LoadType())), 16);
    // Sentinel = 'LoadType | LoadFlags | InternalLoadFlags | TriggeringSandboxFlags'
    (aWriter)->WriteSentinel(236853308);
}

auto ParamTraits<::mozilla::dom::DocShellLoadStateInit>::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 'DocShellLoadStateInit'");
        return {};

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

    }
    auto& _OriginalURI = *maybe___OriginalURI;
    // Sentinel = 'OriginalURI'
    if ((!((aReader)->ReadSentinel(432079910)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'OriginalURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ResultPrincipalURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
    if (!maybe___ResultPrincipalURI) {
        aReader->FatalError("Error deserializing 'ResultPrincipalURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ResultPrincipalURI = *maybe___ResultPrincipalURI;
    // Sentinel = 'ResultPrincipalURI'
    if ((!((aReader)->ReadSentinel(1159202578)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ResultPrincipalURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TriggeringPrincipal = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
    if (!maybe___TriggeringPrincipal) {
        aReader->FatalError("Error deserializing 'TriggeringPrincipal' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TriggeringPrincipal = *maybe___TriggeringPrincipal;
    // Sentinel = 'TriggeringPrincipal'
    if ((!((aReader)->ReadSentinel(1285883829)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringPrincipal' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ReferrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
    if (!maybe___ReferrerInfo) {
        aReader->FatalError("Error deserializing 'ReferrerInfo' (nsIReferrerInfo) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ReferrerInfo = *maybe___ReferrerInfo;
    // Sentinel = 'ReferrerInfo'
    if ((!((aReader)->ReadSentinel(515048650)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ReferrerInfo' (nsIReferrerInfo) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___PrincipalToInherit = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
    if (!maybe___PrincipalToInherit) {
        aReader->FatalError("Error deserializing 'PrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _PrincipalToInherit = *maybe___PrincipalToInherit;
    // Sentinel = 'PrincipalToInherit'
    if ((!((aReader)->ReadSentinel(1138689849)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___PartitionedPrincipalToInherit = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
    if (!maybe___PartitionedPrincipalToInherit) {
        aReader->FatalError("Error deserializing 'PartitionedPrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _PartitionedPrincipalToInherit = *maybe___PartitionedPrincipalToInherit;
    // Sentinel = 'PartitionedPrincipalToInherit'
    if ((!((aReader)->ReadSentinel(2949909436)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'PartitionedPrincipalToInherit' (nsIPrincipal) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___BaseURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
    if (!maybe___BaseURI) {
        aReader->FatalError("Error deserializing 'BaseURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _BaseURI = *maybe___BaseURI;
    // Sentinel = 'BaseURI'
    if ((!((aReader)->ReadSentinel(165282412)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'BaseURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___PolicyContainer = IPC::ReadParam<RefPtr<::nsIPolicyContainer>>(aReader);
    if (!maybe___PolicyContainer) {
        aReader->FatalError("Error deserializing 'PolicyContainer' (nsIPolicyContainer) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _PolicyContainer = *maybe___PolicyContainer;
    // Sentinel = 'PolicyContainer'
    if ((!((aReader)->ReadSentinel(802162196)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'PolicyContainer' (nsIPolicyContainer) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___PostDataStream = IPC::ReadParam<RefPtr<::nsIInputStream>>(aReader);
    if (!maybe___PostDataStream) {
        aReader->FatalError("Error deserializing 'PostDataStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _PostDataStream = *maybe___PostDataStream;
    // Sentinel = 'PostDataStream'
    if ((!((aReader)->ReadSentinel(690292109)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'PostDataStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___HeadersStream = IPC::ReadParam<RefPtr<::nsIInputStream>>(aReader);
    if (!maybe___HeadersStream) {
        aReader->FatalError("Error deserializing 'HeadersStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _HeadersStream = *maybe___HeadersStream;
    // Sentinel = 'HeadersStream'
    if ((!((aReader)->ReadSentinel(589432105)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'HeadersStream' (nsIInputStream) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___UnstrippedURI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
    if (!maybe___UnstrippedURI) {
        aReader->FatalError("Error deserializing 'UnstrippedURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _UnstrippedURI = *maybe___UnstrippedURI;
    // Sentinel = 'UnstrippedURI'
    if ((!((aReader)->ReadSentinel(627967263)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'UnstrippedURI' (nsIURI) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___Target = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___Target) {
        aReader->FatalError("Error deserializing 'Target' (nsString) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _Target = *maybe___Target;
    // Sentinel = 'Target'
    if ((!((aReader)->ReadSentinel(136184424)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Target' (nsString) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TypeHint = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___TypeHint) {
        aReader->FatalError("Error deserializing 'TypeHint' (nsCString) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TypeHint = *maybe___TypeHint;
    // Sentinel = 'TypeHint'
    if ((!((aReader)->ReadSentinel(238748470)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TypeHint' (nsCString) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___FileName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___FileName) {
        aReader->FatalError("Error deserializing 'FileName' (nsString) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _FileName = *maybe___FileName;
    // Sentinel = 'FileName'
    if ((!((aReader)->ReadSentinel(221381378)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'FileName' (nsString) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___SourceBrowsingContext = IPC::ReadParam<::mozilla::dom::MaybeDiscardedBrowsingContext>(aReader);
    if (!maybe___SourceBrowsingContext) {
        aReader->FatalError("Error deserializing 'SourceBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _SourceBrowsingContext = *maybe___SourceBrowsingContext;
    // Sentinel = 'SourceBrowsingContext'
    if ((!((aReader)->ReadSentinel(1569720482)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'SourceBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TargetBrowsingContext = IPC::ReadParam<::mozilla::dom::MaybeDiscardedBrowsingContext>(aReader);
    if (!maybe___TargetBrowsingContext) {
        aReader->FatalError("Error deserializing 'TargetBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TargetBrowsingContext = *maybe___TargetBrowsingContext;
    // Sentinel = 'TargetBrowsingContext'
    if ((!((aReader)->ReadSentinel(1553991832)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TargetBrowsingContext' (MaybeDiscardedBrowsingContext) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TriggeringRemoteType = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___TriggeringRemoteType) {
        aReader->FatalError("Error deserializing 'TriggeringRemoteType' (nsCString) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TriggeringRemoteType = *maybe___TriggeringRemoteType;
    // Sentinel = 'TriggeringRemoteType'
    if ((!((aReader)->ReadSentinel(1421281313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringRemoteType' (nsCString) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___SrcdocData = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___SrcdocData) {
        aReader->FatalError("Error deserializing 'SrcdocData' (nsString) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _SrcdocData = *maybe___SrcdocData;
    // Sentinel = 'SrcdocData'
    if ((!((aReader)->ReadSentinel(354616281)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'SrcdocData' (nsString) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___OriginalURIString = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___OriginalURIString) {
        aReader->FatalError("Error deserializing 'OriginalURIString' (nsCString?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _OriginalURIString = *maybe___OriginalURIString;
    // Sentinel = 'OriginalURIString'
    if ((!((aReader)->ReadSentinel(992020125)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'OriginalURIString' (nsCString?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___RemoteTypeOverride = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___RemoteTypeOverride) {
        aReader->FatalError("Error deserializing 'RemoteTypeOverride' (nsCString?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _RemoteTypeOverride = *maybe___RemoteTypeOverride;
    // Sentinel = 'RemoteTypeOverride'
    if ((!((aReader)->ReadSentinel(1155467087)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RemoteTypeOverride' (nsCString?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___loadingSessionHistoryInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::LoadingSessionHistoryInfo>>(aReader);
    if (!maybe___loadingSessionHistoryInfo) {
        aReader->FatalError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _loadingSessionHistoryInfo = *maybe___loadingSessionHistoryInfo;
    // Sentinel = 'loadingSessionHistoryInfo'
    if ((!((aReader)->ReadSentinel(2228161089)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'loadingSessionHistoryInfo' (LoadingSessionHistoryInfo?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___userNavigationInvolvement = IPC::ReadParam<::mozilla::dom::UserNavigationInvolvement>(aReader);
    if (!maybe___userNavigationInvolvement) {
        aReader->FatalError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _userNavigationInvolvement = *maybe___userNavigationInvolvement;
    // Sentinel = 'userNavigationInvolvement'
    if ((!((aReader)->ReadSentinel(2256013927)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'userNavigationInvolvement' (UserNavigationInvolvement) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TriggeringStorageAccess = IPC::ReadParam<bool>(aReader);
    if (!maybe___TriggeringStorageAccess) {
        aReader->FatalError("Error deserializing 'TriggeringStorageAccess' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TriggeringStorageAccess = *maybe___TriggeringStorageAccess;
    // Sentinel = 'TriggeringStorageAccess'
    if ((!((aReader)->ReadSentinel(1859782970)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringStorageAccess' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TriggeringClassificationFlags = IPC::ReadParam<::mozilla::net::ClassificationFlags>(aReader);
    if (!maybe___TriggeringClassificationFlags) {
        aReader->FatalError("Error deserializing 'TriggeringClassificationFlags' (ClassificationFlags) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TriggeringClassificationFlags = *maybe___TriggeringClassificationFlags;
    // Sentinel = 'TriggeringClassificationFlags'
    if ((!((aReader)->ReadSentinel(2931559340)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TriggeringClassificationFlags' (ClassificationFlags) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___CancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<::int32_t>>(aReader);
    if (!maybe___CancelContentJSEpoch) {
        aReader->FatalError("Error deserializing 'CancelContentJSEpoch' (int32_t?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _CancelContentJSEpoch = *maybe___CancelContentJSEpoch;
    // Sentinel = 'CancelContentJSEpoch'
    if ((!((aReader)->ReadSentinel(1340278702)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CancelContentJSEpoch' (int32_t?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ResultPrincipalURIIsSome = IPC::ReadParam<bool>(aReader);
    if (!maybe___ResultPrincipalURIIsSome) {
        aReader->FatalError("Error deserializing 'ResultPrincipalURIIsSome' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ResultPrincipalURIIsSome = *maybe___ResultPrincipalURIIsSome;
    // Sentinel = 'ResultPrincipalURIIsSome'
    if ((!((aReader)->ReadSentinel(2001799522)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ResultPrincipalURIIsSome' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___KeepResultPrincipalURIIfSet = IPC::ReadParam<bool>(aReader);
    if (!maybe___KeepResultPrincipalURIIfSet) {
        aReader->FatalError("Error deserializing 'KeepResultPrincipalURIIfSet' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _KeepResultPrincipalURIIfSet = *maybe___KeepResultPrincipalURIIfSet;
    // Sentinel = 'KeepResultPrincipalURIIfSet'
    if ((!((aReader)->ReadSentinel(2486831730)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'KeepResultPrincipalURIIfSet' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___LoadReplace = IPC::ReadParam<bool>(aReader);
    if (!maybe___LoadReplace) {
        aReader->FatalError("Error deserializing 'LoadReplace' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _LoadReplace = *maybe___LoadReplace;
    // Sentinel = 'LoadReplace'
    if ((!((aReader)->ReadSentinel(418907197)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'LoadReplace' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___InheritPrincipal = IPC::ReadParam<bool>(aReader);
    if (!maybe___InheritPrincipal) {
        aReader->FatalError("Error deserializing 'InheritPrincipal' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _InheritPrincipal = *maybe___InheritPrincipal;
    // Sentinel = 'InheritPrincipal'
    if ((!((aReader)->ReadSentinel(908723830)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'InheritPrincipal' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___PrincipalIsExplicit = IPC::ReadParam<bool>(aReader);
    if (!maybe___PrincipalIsExplicit) {
        aReader->FatalError("Error deserializing 'PrincipalIsExplicit' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _PrincipalIsExplicit = *maybe___PrincipalIsExplicit;
    // Sentinel = 'PrincipalIsExplicit'
    if ((!((aReader)->ReadSentinel(1265567649)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalIsExplicit' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___NotifiedBeforeUnloadListeners = IPC::ReadParam<bool>(aReader);
    if (!maybe___NotifiedBeforeUnloadListeners) {
        aReader->FatalError("Error deserializing 'NotifiedBeforeUnloadListeners' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _NotifiedBeforeUnloadListeners = *maybe___NotifiedBeforeUnloadListeners;
    // Sentinel = 'NotifiedBeforeUnloadListeners'
    if ((!((aReader)->ReadSentinel(2882538402)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'NotifiedBeforeUnloadListeners' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ForceAllowDataURI = IPC::ReadParam<bool>(aReader);
    if (!maybe___ForceAllowDataURI) {
        aReader->FatalError("Error deserializing 'ForceAllowDataURI' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ForceAllowDataURI = *maybe___ForceAllowDataURI;
    // Sentinel = 'ForceAllowDataURI'
    if ((!((aReader)->ReadSentinel(977077849)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ForceAllowDataURI' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___IsExemptFromHTTPSFirstMode = IPC::ReadParam<bool>(aReader);
    if (!maybe___IsExemptFromHTTPSFirstMode) {
        aReader->FatalError("Error deserializing 'IsExemptFromHTTPSFirstMode' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _IsExemptFromHTTPSFirstMode = *maybe___IsExemptFromHTTPSFirstMode;
    // Sentinel = 'IsExemptFromHTTPSFirstMode'
    if ((!((aReader)->ReadSentinel(2233272804)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IsExemptFromHTTPSFirstMode' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___OriginalFrameSrc = IPC::ReadParam<bool>(aReader);
    if (!maybe___OriginalFrameSrc) {
        aReader->FatalError("Error deserializing 'OriginalFrameSrc' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _OriginalFrameSrc = *maybe___OriginalFrameSrc;
    // Sentinel = 'OriginalFrameSrc'
    if ((!((aReader)->ReadSentinel(896271945)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'OriginalFrameSrc' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ShouldCheckForRecursion = IPC::ReadParam<bool>(aReader);
    if (!maybe___ShouldCheckForRecursion) {
        aReader->FatalError("Error deserializing 'ShouldCheckForRecursion' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ShouldCheckForRecursion = *maybe___ShouldCheckForRecursion;
    // Sentinel = 'ShouldCheckForRecursion'
    if ((!((aReader)->ReadSentinel(1812531503)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ShouldCheckForRecursion' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___IsFormSubmission = IPC::ReadParam<bool>(aReader);
    if (!maybe___IsFormSubmission) {
        aReader->FatalError("Error deserializing 'IsFormSubmission' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _IsFormSubmission = *maybe___IsFormSubmission;
    // Sentinel = 'IsFormSubmission'
    if ((!((aReader)->ReadSentinel(893978237)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IsFormSubmission' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___FirstParty = IPC::ReadParam<bool>(aReader);
    if (!maybe___FirstParty) {
        aReader->FatalError("Error deserializing 'FirstParty' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _FirstParty = *maybe___FirstParty;
    // Sentinel = 'FirstParty'
    if ((!((aReader)->ReadSentinel(363791385)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'FirstParty' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___HasValidUserGestureActivation = IPC::ReadParam<bool>(aReader);
    if (!maybe___HasValidUserGestureActivation) {
        aReader->FatalError("Error deserializing 'HasValidUserGestureActivation' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _HasValidUserGestureActivation = *maybe___HasValidUserGestureActivation;
    // Sentinel = 'HasValidUserGestureActivation'
    if ((!((aReader)->ReadSentinel(2853571485)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'HasValidUserGestureActivation' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TextDirectiveUserActivation = IPC::ReadParam<bool>(aReader);
    if (!maybe___TextDirectiveUserActivation) {
        aReader->FatalError("Error deserializing 'TextDirectiveUserActivation' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TextDirectiveUserActivation = *maybe___TextDirectiveUserActivation;
    // Sentinel = 'TextDirectiveUserActivation'
    if ((!((aReader)->ReadSentinel(2543389430)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TextDirectiveUserActivation' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___AllowFocusMove = IPC::ReadParam<bool>(aReader);
    if (!maybe___AllowFocusMove) {
        aReader->FatalError("Error deserializing 'AllowFocusMove' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _AllowFocusMove = *maybe___AllowFocusMove;
    // Sentinel = 'AllowFocusMove'
    if ((!((aReader)->ReadSentinel(688194967)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AllowFocusMove' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___IsFromProcessingFrameAttributes = IPC::ReadParam<bool>(aReader);
    if (!maybe___IsFromProcessingFrameAttributes) {
        aReader->FatalError("Error deserializing 'IsFromProcessingFrameAttributes' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _IsFromProcessingFrameAttributes = *maybe___IsFromProcessingFrameAttributes;
    // Sentinel = 'IsFromProcessingFrameAttributes'
    if ((!((aReader)->ReadSentinel(3294956672)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IsFromProcessingFrameAttributes' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___NeedsCompletelyLoadedDocument = IPC::ReadParam<bool>(aReader);
    if (!maybe___NeedsCompletelyLoadedDocument) {
        aReader->FatalError("Error deserializing 'NeedsCompletelyLoadedDocument' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _NeedsCompletelyLoadedDocument = *maybe___NeedsCompletelyLoadedDocument;
    // Sentinel = 'NeedsCompletelyLoadedDocument'
    if ((!((aReader)->ReadSentinel(2878016406)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'NeedsCompletelyLoadedDocument' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ShouldNotForceReplaceInOnLoad = IPC::ReadParam<bool>(aReader);
    if (!maybe___ShouldNotForceReplaceInOnLoad) {
        aReader->FatalError("Error deserializing 'ShouldNotForceReplaceInOnLoad' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ShouldNotForceReplaceInOnLoad = *maybe___ShouldNotForceReplaceInOnLoad;
    // Sentinel = 'ShouldNotForceReplaceInOnLoad'
    if ((!((aReader)->ReadSentinel(2863270720)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ShouldNotForceReplaceInOnLoad' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___HistoryBehavior = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::NavigationHistoryBehavior>>(aReader);
    if (!maybe___HistoryBehavior) {
        aReader->FatalError("Error deserializing 'HistoryBehavior' (NavigationHistoryBehavior?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _HistoryBehavior = *maybe___HistoryBehavior;
    // Sentinel = 'HistoryBehavior'
    if ((!((aReader)->ReadSentinel(810616355)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'HistoryBehavior' (NavigationHistoryBehavior?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___SchemelessInput = IPC::ReadParam<::nsILoadInfo::SchemelessInputType>(aReader);
    if (!maybe___SchemelessInput) {
        aReader->FatalError("Error deserializing 'SchemelessInput' (SchemelessInputType) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _SchemelessInput = *maybe___SchemelessInput;
    // Sentinel = 'SchemelessInput'
    if ((!((aReader)->ReadSentinel(798557725)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'SchemelessInput' (SchemelessInputType) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___forceMediaDocument = IPC::ReadParam<::mozilla::dom::ForceMediaDocument>(aReader);
    if (!maybe___forceMediaDocument) {
        aReader->FatalError("Error deserializing 'forceMediaDocument' (ForceMediaDocument) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _forceMediaDocument = *maybe___forceMediaDocument;
    // Sentinel = 'forceMediaDocument'
    if ((!((aReader)->ReadSentinel(1132136239)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'forceMediaDocument' (ForceMediaDocument) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___HttpsUpgradeTelemetry = IPC::ReadParam<::nsILoadInfo::HTTPSUpgradeTelemetryType>(aReader);
    if (!maybe___HttpsUpgradeTelemetry) {
        aReader->FatalError("Error deserializing 'HttpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _HttpsUpgradeTelemetry = *maybe___HttpsUpgradeTelemetry;
    // Sentinel = 'HttpsUpgradeTelemetry'
    if ((!((aReader)->ReadSentinel(1562249367)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'HttpsUpgradeTelemetry' (HTTPSUpgradeTelemetryType) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___NavigationAPIState = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ClonedMessageData>>(aReader);
    if (!maybe___NavigationAPIState) {
        aReader->FatalError("Error deserializing 'NavigationAPIState' (ClonedMessageData?) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _NavigationAPIState = *maybe___NavigationAPIState;
    // Sentinel = 'NavigationAPIState'
    if ((!((aReader)->ReadSentinel(1107887852)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'NavigationAPIState' (ClonedMessageData?) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___ChannelInitialized = IPC::ReadParam<bool>(aReader);
    if (!maybe___ChannelInitialized) {
        aReader->FatalError("Error deserializing 'ChannelInitialized' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _ChannelInitialized = *maybe___ChannelInitialized;
    // Sentinel = 'ChannelInitialized'
    if ((!((aReader)->ReadSentinel(1118308144)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ChannelInitialized' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___TryToReplaceWithSessionHistoryLoad = IPC::ReadParam<bool>(aReader);
    if (!maybe___TryToReplaceWithSessionHistoryLoad) {
        aReader->FatalError("Error deserializing 'TryToReplaceWithSessionHistoryLoad' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _TryToReplaceWithSessionHistoryLoad = *maybe___TryToReplaceWithSessionHistoryLoad;
    // Sentinel = 'TryToReplaceWithSessionHistoryLoad'
    if ((!((aReader)->ReadSentinel(3987606961)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TryToReplaceWithSessionHistoryLoad' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___IsMetaRefresh = IPC::ReadParam<bool>(aReader);
    if (!maybe___IsMetaRefresh) {
        aReader->FatalError("Error deserializing 'IsMetaRefresh' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _IsMetaRefresh = *maybe___IsMetaRefresh;
    // Sentinel = 'IsMetaRefresh'
    if ((!((aReader)->ReadSentinel(576849171)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IsMetaRefresh' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    auto maybe___IsCaptivePortalTab = IPC::ReadParam<bool>(aReader);
    if (!maybe___IsCaptivePortalTab) {
        aReader->FatalError("Error deserializing 'IsCaptivePortalTab' (bool) member of 'DocShellLoadStateInit'");
        return {};

    }
    auto& _IsCaptivePortalTab = *maybe___IsCaptivePortalTab;
    // Sentinel = 'IsCaptivePortalTab'
    if ((!((aReader)->ReadSentinel(1115490066)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IsCaptivePortalTab' (bool) member of 'DocShellLoadStateInit'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_URI),
            std::move(_OriginalURI),
            std::move(_ResultPrincipalURI),
            std::move(_TriggeringPrincipal),
            std::move(_ReferrerInfo),
            std::move(_PrincipalToInherit),
            std::move(_PartitionedPrincipalToInherit),
            std::move(_BaseURI),
            std::move(_PolicyContainer),
            std::move(_PostDataStream),
            std::move(_HeadersStream),
            std::move(_UnstrippedURI),
            ::uint64_t{0},
            std::move(_Target),
            std::move(_TypeHint),
            std::move(_FileName),
            std::move(_SourceBrowsingContext),
            std::move(_TargetBrowsingContext),
            std::move(_TriggeringRemoteType),
            std::move(_SrcdocData),
            std::move(_OriginalURIString),
            std::move(_RemoteTypeOverride),
            std::move(_loadingSessionHistoryInfo),
            ::uint32_t{0},
            ::uint32_t{0},
            ::uint32_t{0},
            std::move(_userNavigationInvolvement),
            ::uint32_t{0},
            ::uint64_t{0},
            std::move(_TriggeringStorageAccess),
            std::move(_TriggeringClassificationFlags),
            std::move(_CancelContentJSEpoch),
            std::move(_ResultPrincipalURIIsSome),
            std::move(_KeepResultPrincipalURIIfSet),
            std::move(_LoadReplace),
            std::move(_InheritPrincipal),
            std::move(_PrincipalIsExplicit),
            std::move(_NotifiedBeforeUnloadListeners),
            std::move(_ForceAllowDataURI),
            std::move(_IsExemptFromHTTPSFirstMode),
            std::move(_OriginalFrameSrc),
            std::move(_ShouldCheckForRecursion),
            std::move(_IsFormSubmission),
            std::move(_FirstParty),
            std::move(_HasValidUserGestureActivation),
            std::move(_TextDirectiveUserActivation),
            std::move(_AllowFocusMove),
            std::move(_IsFromProcessingFrameAttributes),
            std::move(_NeedsCompletelyLoadedDocument),
            std::move(_ShouldNotForceReplaceInOnLoad),
            std::move(_HistoryBehavior),
            std::move(_SchemelessInput),
            std::move(_forceMediaDocument),
            std::move(_HttpsUpgradeTelemetry),
            std::move(_NavigationAPIState),
            std::move(_ChannelInitialized),
            std::move(_TryToReplaceWithSessionHistoryLoad),
            std::move(_IsMetaRefresh),
            std::move(_IsCaptivePortalTab)};
    if ((!((aReader)->ReadBytesInto((&((result__)->LoadIdentifier())), 16)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'LoadIdentifier | TriggeringWindowId'
    if ((!((aReader)->ReadSentinel(4016246135)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->LoadType())), 16)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'LoadType | LoadFlags | InternalLoadFlags | TriggeringSandboxFlags'
    if ((!((aReader)->ReadSentinel(236853308)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TimedChannelInfo|
//
namespace mozilla {
namespace dom {
auto TimedChannelInfo::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(TimedChannelInfo, internalRedirectCount_) - offsetof(TimedChannelInfo, redirectCount_)) == 1,
        "Bad assumptions about field layout!");
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::TimedChannelInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).asyncOpen());
    // Sentinel = 'asyncOpen'
    (aWriter)->WriteSentinel(312476593);
    IPC::WriteParam(aWriter, (aVar).channelCreation());
    // Sentinel = 'channelCreation'
    (aWriter)->WriteSentinel(803800591);
    IPC::WriteParam(aWriter, (aVar).redirectStart());
    // Sentinel = 'redirectStart'
    (aWriter)->WriteSentinel(628753761);
    IPC::WriteParam(aWriter, (aVar).redirectEnd());
    // Sentinel = 'redirectEnd'
    (aWriter)->WriteSentinel(452527210);
    IPC::WriteParam(aWriter, (aVar).initiatorType());
    // Sentinel = 'initiatorType'
    (aWriter)->WriteSentinel(642647414);
    IPC::WriteParam(aWriter, (aVar).allRedirectsSameOrigin());
    // Sentinel = 'allRedirectsSameOrigin'
    (aWriter)->WriteSentinel(1689716941);
    IPC::WriteParam(aWriter, (aVar).allRedirectsPassTimingAllowCheck());
    // Sentinel = 'allRedirectsPassTimingAllowCheck'
    (aWriter)->WriteSentinel(3535342779);
    IPC::WriteParam(aWriter, (aVar).timingAllowCheckForPrincipal());
    // Sentinel = 'timingAllowCheckForPrincipal'
    (aWriter)->WriteSentinel(2723941167);
    IPC::WriteParam(aWriter, (aVar).renderBlocking());
    // Sentinel = 'renderBlocking'
    (aWriter)->WriteSentinel(713688490);
    IPC::WriteParam(aWriter, (aVar).launchServiceWorkerStart());
    // Sentinel = 'launchServiceWorkerStart'
    (aWriter)->WriteSentinel(2052262357);
    IPC::WriteParam(aWriter, (aVar).launchServiceWorkerEnd());
    // Sentinel = 'launchServiceWorkerEnd'
    (aWriter)->WriteSentinel(1726613726);
    IPC::WriteParam(aWriter, (aVar).dispatchFetchEventStart());
    // Sentinel = 'dispatchFetchEventStart'
    (aWriter)->WriteSentinel(1861880139);
    IPC::WriteParam(aWriter, (aVar).dispatchFetchEventEnd());
    // Sentinel = 'dispatchFetchEventEnd'
    (aWriter)->WriteSentinel(1554319444);
    IPC::WriteParam(aWriter, (aVar).handleFetchEventStart());
    // Sentinel = 'handleFetchEventStart'
    (aWriter)->WriteSentinel(1529022567);
    IPC::WriteParam(aWriter, (aVar).handleFetchEventEnd());
    // Sentinel = 'handleFetchEventEnd'
    (aWriter)->WriteSentinel(1251346288);
    IPC::WriteParam(aWriter, (aVar).responseStart());
    // Sentinel = 'responseStart'
    (aWriter)->WriteSentinel(648545662);
    IPC::WriteParam(aWriter, (aVar).responseEnd());
    // Sentinel = 'responseEnd'
    (aWriter)->WriteSentinel(468518023);
    (aWriter)->WriteBytes((&((aVar).redirectCount())), 2);
    // Sentinel = 'redirectCount | internalRedirectCount'
    (aWriter)->WriteSentinel(359534256);
}

auto ParamTraits<::mozilla::dom::TimedChannelInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___asyncOpen = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___asyncOpen) {
        aReader->FatalError("Error deserializing 'asyncOpen' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _asyncOpen = *maybe___asyncOpen;
    // Sentinel = 'asyncOpen'
    if ((!((aReader)->ReadSentinel(312476593)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'asyncOpen' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___channelCreation = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___channelCreation) {
        aReader->FatalError("Error deserializing 'channelCreation' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _channelCreation = *maybe___channelCreation;
    // Sentinel = 'channelCreation'
    if ((!((aReader)->ReadSentinel(803800591)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'channelCreation' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___redirectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___redirectStart) {
        aReader->FatalError("Error deserializing 'redirectStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _redirectStart = *maybe___redirectStart;
    // Sentinel = 'redirectStart'
    if ((!((aReader)->ReadSentinel(628753761)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'redirectStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___redirectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___redirectEnd) {
        aReader->FatalError("Error deserializing 'redirectEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _redirectEnd = *maybe___redirectEnd;
    // Sentinel = 'redirectEnd'
    if ((!((aReader)->ReadSentinel(452527210)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'redirectEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___initiatorType = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___initiatorType) {
        aReader->FatalError("Error deserializing 'initiatorType' (nsString) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _initiatorType = *maybe___initiatorType;
    // Sentinel = 'initiatorType'
    if ((!((aReader)->ReadSentinel(642647414)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'initiatorType' (nsString) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___allRedirectsSameOrigin = IPC::ReadParam<bool>(aReader);
    if (!maybe___allRedirectsSameOrigin) {
        aReader->FatalError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _allRedirectsSameOrigin = *maybe___allRedirectsSameOrigin;
    // Sentinel = 'allRedirectsSameOrigin'
    if ((!((aReader)->ReadSentinel(1689716941)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___allRedirectsPassTimingAllowCheck = IPC::ReadParam<bool>(aReader);
    if (!maybe___allRedirectsPassTimingAllowCheck) {
        aReader->FatalError("Error deserializing 'allRedirectsPassTimingAllowCheck' (bool) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _allRedirectsPassTimingAllowCheck = *maybe___allRedirectsPassTimingAllowCheck;
    // Sentinel = 'allRedirectsPassTimingAllowCheck'
    if ((!((aReader)->ReadSentinel(3535342779)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsPassTimingAllowCheck' (bool) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___timingAllowCheckForPrincipal = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
    if (!maybe___timingAllowCheckForPrincipal) {
        aReader->FatalError("Error deserializing 'timingAllowCheckForPrincipal' (bool?) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _timingAllowCheckForPrincipal = *maybe___timingAllowCheckForPrincipal;
    // Sentinel = 'timingAllowCheckForPrincipal'
    if ((!((aReader)->ReadSentinel(2723941167)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timingAllowCheckForPrincipal' (bool?) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___renderBlocking = IPC::ReadParam<bool>(aReader);
    if (!maybe___renderBlocking) {
        aReader->FatalError("Error deserializing 'renderBlocking' (bool) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _renderBlocking = *maybe___renderBlocking;
    // Sentinel = 'renderBlocking'
    if ((!((aReader)->ReadSentinel(713688490)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'renderBlocking' (bool) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___launchServiceWorkerStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___launchServiceWorkerStart) {
        aReader->FatalError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _launchServiceWorkerStart = *maybe___launchServiceWorkerStart;
    // Sentinel = 'launchServiceWorkerStart'
    if ((!((aReader)->ReadSentinel(2052262357)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___launchServiceWorkerEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___launchServiceWorkerEnd) {
        aReader->FatalError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _launchServiceWorkerEnd = *maybe___launchServiceWorkerEnd;
    // Sentinel = 'launchServiceWorkerEnd'
    if ((!((aReader)->ReadSentinel(1726613726)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___dispatchFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___dispatchFetchEventStart) {
        aReader->FatalError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _dispatchFetchEventStart = *maybe___dispatchFetchEventStart;
    // Sentinel = 'dispatchFetchEventStart'
    if ((!((aReader)->ReadSentinel(1861880139)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___dispatchFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___dispatchFetchEventEnd) {
        aReader->FatalError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _dispatchFetchEventEnd = *maybe___dispatchFetchEventEnd;
    // Sentinel = 'dispatchFetchEventEnd'
    if ((!((aReader)->ReadSentinel(1554319444)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___handleFetchEventStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___handleFetchEventStart) {
        aReader->FatalError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _handleFetchEventStart = *maybe___handleFetchEventStart;
    // Sentinel = 'handleFetchEventStart'
    if ((!((aReader)->ReadSentinel(1529022567)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___handleFetchEventEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___handleFetchEventEnd) {
        aReader->FatalError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _handleFetchEventEnd = *maybe___handleFetchEventEnd;
    // Sentinel = 'handleFetchEventEnd'
    if ((!((aReader)->ReadSentinel(1251346288)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___responseStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___responseStart) {
        aReader->FatalError("Error deserializing 'responseStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _responseStart = *maybe___responseStart;
    // Sentinel = 'responseStart'
    if ((!((aReader)->ReadSentinel(648545662)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'responseStart' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    auto maybe___responseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___responseEnd) {
        aReader->FatalError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};

    }
    auto& _responseEnd = *maybe___responseEnd;
    // Sentinel = 'responseEnd'
    if ((!((aReader)->ReadSentinel(468518023)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'responseEnd' (TimeStamp) member of 'TimedChannelInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int8_t{0},
            ::int8_t{0},
            std::move(_asyncOpen),
            std::move(_channelCreation),
            std::move(_redirectStart),
            std::move(_redirectEnd),
            std::move(_initiatorType),
            std::move(_allRedirectsSameOrigin),
            std::move(_allRedirectsPassTimingAllowCheck),
            std::move(_timingAllowCheckForPrincipal),
            std::move(_renderBlocking),
            std::move(_launchServiceWorkerStart),
            std::move(_launchServiceWorkerEnd),
            std::move(_dispatchFetchEventStart),
            std::move(_dispatchFetchEventEnd),
            std::move(_handleFetchEventStart),
            std::move(_handleFetchEventEnd),
            std::move(_responseStart),
            std::move(_responseEnd)};
    if ((!((aReader)->ReadBytesInto((&((result__)->redirectCount())), 2)))) {
        aReader->FatalError("Error bulk reading fields from int8_t");
        return {};
    }
    // Sentinel = 'redirectCount | internalRedirectCount'
    if ((!((aReader)->ReadSentinel(359534256)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int8_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ReplacementChannelConfigInit>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).classOfService());
    // Sentinel = 'classOfService'
    (aWriter)->WriteSentinel(704710045);
    IPC::WriteParam(aWriter, (aVar).privateBrowsing());
    // Sentinel = 'privateBrowsing'
    (aWriter)->WriteSentinel(844957255);
    IPC::WriteParam(aWriter, (aVar).method());
    // Sentinel = 'method'
    (aWriter)->WriteSentinel(148308610);
    IPC::WriteParam(aWriter, (aVar).referrerInfo());
    // Sentinel = 'referrerInfo'
    (aWriter)->WriteSentinel(540214506);
    IPC::WriteParam(aWriter, (aVar).timedChannelInfo());
    // Sentinel = 'timedChannelInfo'
    (aWriter)->WriteSentinel(908920409);
    IPC::WriteParam(aWriter, (aVar).uploadStream());
    // Sentinel = 'uploadStream'
    (aWriter)->WriteSentinel(546768114);
    IPC::WriteParam(aWriter, (aVar).uploadStreamHasHeaders());
    // Sentinel = 'uploadStreamHasHeaders'
    (aWriter)->WriteSentinel(1714227402);
    IPC::WriteParam(aWriter, (aVar).contentType());
    // Sentinel = 'contentType'
    (aWriter)->WriteSentinel(465241246);
    IPC::WriteParam(aWriter, (aVar).contentLength());
    // Sentinel = 'contentLength'
    (aWriter)->WriteSentinel(632358238);
    (aWriter)->WriteBytes((&((aVar).uploadStreamLength())), 8);
    // Sentinel = 'uploadStreamLength'
    (aWriter)->WriteSentinel(1178666836);
    (aWriter)->WriteBytes((&((aVar).redirectFlags())), 4);
    // Sentinel = 'redirectFlags'
    (aWriter)->WriteSentinel(620889408);
}

auto ParamTraits<::mozilla::dom::ReplacementChannelConfigInit>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___classOfService = IPC::ReadParam<::mozilla::net::ClassOfService>(aReader);
    if (!maybe___classOfService) {
        aReader->FatalError("Error deserializing 'classOfService' (ClassOfService) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _classOfService = *maybe___classOfService;
    // Sentinel = 'classOfService'
    if ((!((aReader)->ReadSentinel(704710045)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'classOfService' (ClassOfService) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___privateBrowsing = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
    if (!maybe___privateBrowsing) {
        aReader->FatalError("Error deserializing 'privateBrowsing' (bool?) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _privateBrowsing = *maybe___privateBrowsing;
    // Sentinel = 'privateBrowsing'
    if ((!((aReader)->ReadSentinel(844957255)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'privateBrowsing' (bool?) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___method = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___method) {
        aReader->FatalError("Error deserializing 'method' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _method = *maybe___method;
    // Sentinel = 'method'
    if ((!((aReader)->ReadSentinel(148308610)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'method' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___referrerInfo = IPC::ReadParam<RefPtr<::nsIReferrerInfo>>(aReader);
    if (!maybe___referrerInfo) {
        aReader->FatalError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _referrerInfo = *maybe___referrerInfo;
    // Sentinel = 'referrerInfo'
    if ((!((aReader)->ReadSentinel(540214506)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'referrerInfo' (nsIReferrerInfo) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___timedChannelInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::TimedChannelInfo>>(aReader);
    if (!maybe___timedChannelInfo) {
        aReader->FatalError("Error deserializing 'timedChannelInfo' (TimedChannelInfo?) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _timedChannelInfo = *maybe___timedChannelInfo;
    // Sentinel = 'timedChannelInfo'
    if ((!((aReader)->ReadSentinel(908920409)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timedChannelInfo' (TimedChannelInfo?) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___uploadStream = IPC::ReadParam<RefPtr<::mozilla::RemoteLazyInputStream>>(aReader);
    if (!maybe___uploadStream) {
        aReader->FatalError("Error deserializing 'uploadStream' (RemoteLazyInputStream) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _uploadStream = *maybe___uploadStream;
    // Sentinel = 'uploadStream'
    if ((!((aReader)->ReadSentinel(546768114)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (RemoteLazyInputStream) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___uploadStreamHasHeaders = IPC::ReadParam<bool>(aReader);
    if (!maybe___uploadStreamHasHeaders) {
        aReader->FatalError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _uploadStreamHasHeaders = *maybe___uploadStreamHasHeaders;
    // Sentinel = 'uploadStreamHasHeaders'
    if ((!((aReader)->ReadSentinel(1714227402)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___contentType = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___contentType) {
        aReader->FatalError("Error deserializing 'contentType' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _contentType = *maybe___contentType;
    // Sentinel = 'contentType'
    if ((!((aReader)->ReadSentinel(465241246)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    auto maybe___contentLength = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___contentLength) {
        aReader->FatalError("Error deserializing 'contentLength' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};

    }
    auto& _contentLength = *maybe___contentLength;
    // Sentinel = 'contentLength'
    if ((!((aReader)->ReadSentinel(632358238)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentLength' (nsCString?) member of 'ReplacementChannelConfigInit'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            std::move(_classOfService),
            std::move(_privateBrowsing),
            std::move(_method),
            std::move(_referrerInfo),
            std::move(_timedChannelInfo),
            std::move(_uploadStream),
            ::uint64_t{0},
            std::move(_uploadStreamHasHeaders),
            std::move(_contentType),
            std::move(_contentLength)};
    if ((!((aReader)->ReadBytesInto((&((result__)->uploadStreamLength())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'uploadStreamLength'
    if ((!((aReader)->ReadSentinel(1178666836)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->redirectFlags())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'redirectFlags'
    if ((!((aReader)->ReadSentinel(620889408)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPDLVariantValue|
//
namespace mozilla {
namespace dom {
auto IPDLVariantValue::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tbool:
        {
            (ptr_bool())->~bool__tdef();
            break;
        }
    case Tuint8_t:
        {
            (ptr_uint8_t())->~uint8_t__tdef();
            break;
        }
    case Tint16_t:
        {
            (ptr_int16_t())->~int16_t__tdef();
            break;
        }
    case Tuint16_t:
        {
            (ptr_uint16_t())->~uint16_t__tdef();
            break;
        }
    case Tint32_t:
        {
            (ptr_int32_t())->~int32_t__tdef();
            break;
        }
    case Tuint32_t:
        {
            (ptr_uint32_t())->~uint32_t__tdef();
            break;
        }
    case Tfloat:
        {
            (ptr_float())->~float__tdef();
            break;
        }
    case Tdouble:
        {
            (ptr_double())->~double__tdef();
            break;
        }
    case TnsID:
        {
            (ptr_nsID())->~nsID__tdef();
            break;
        }
    case TnsString:
        {
            (ptr_nsString())->~nsString__tdef();
            break;
        }
    case TnsCString:
        {
            (ptr_nsCString())->~nsCString__tdef();
            break;
        }
    case TnsIURI:
        {
            (ptr_nsIURI())->~nsIURI__tdef();
            break;
        }
    case TnsIPrincipal:
        {
            (ptr_nsIPrincipal())->~nsIPrincipal__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const bool& aOther)
{
    new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
    mType = Tbool;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(bool&& aOther)
{
    new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aOther));
    mType = Tbool;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint8_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(aOther);
    mType = Tuint8_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint8_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move(aOther));
    mType = Tuint8_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const int16_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(aOther);
    mType = Tint16_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(int16_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move(aOther));
    mType = Tint16_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint16_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(aOther);
    mType = Tuint16_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint16_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move(aOther));
    mType = Tuint16_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const int32_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aOther);
    mType = Tint32_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(int32_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aOther));
    mType = Tint32_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const uint32_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(aOther);
    mType = Tuint32_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(uint32_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move(aOther));
    mType = Tuint32_t;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const float& aOther)
{
    new (mozilla::KnownNotNull, ptr_float()) float(aOther);
    mType = Tfloat;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(float&& aOther)
{
    new (mozilla::KnownNotNull, ptr_float()) float(std::move(aOther));
    mType = Tfloat;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const double& aOther)
{
    new (mozilla::KnownNotNull, ptr_double()) double(aOther);
    mType = Tdouble;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(double&& aOther)
{
    new (mozilla::KnownNotNull, ptr_double()) double(std::move(aOther));
    mType = Tdouble;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsID& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsID()) nsID(aOther);
    mType = TnsID;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsID&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move(aOther));
    mType = TnsID;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsString& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(aOther);
    mType = TnsString;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsString&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aOther));
    mType = TnsString;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const nsCString& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aOther);
    mType = TnsCString;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsCString&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aOther));
    mType = TnsCString;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsIURI* aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(aOther);
    mType = TnsIURI;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(RefPtr<nsIURI>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move(aOther));
    mType = TnsIURI;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(nsIPrincipal* aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(aOther);
    mType = TnsIPrincipal;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(RefPtr<nsIPrincipal>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move(aOther));
    mType = TnsIPrincipal;
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(const IPDLVariantValue& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tbool:
        {
            new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
            break;
        }
    case Tuint8_t:
        {
            new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t((aOther).get_uint8_t());
            break;
        }
    case Tint16_t:
        {
            new (mozilla::KnownNotNull, ptr_int16_t()) int16_t((aOther).get_int16_t());
            break;
        }
    case Tuint16_t:
        {
            new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t((aOther).get_uint16_t());
            break;
        }
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aOther).get_int32_t());
            break;
        }
    case Tuint32_t:
        {
            new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t((aOther).get_uint32_t());
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
            break;
        }
    case Tdouble:
        {
            new (mozilla::KnownNotNull, ptr_double()) double((aOther).get_double());
            break;
        }
    case TnsID:
        {
            new (mozilla::KnownNotNull, ptr_nsID()) nsID((aOther).get_nsID());
            break;
        }
    case TnsString:
        {
            new (mozilla::KnownNotNull, ptr_nsString()) nsString((aOther).get_nsString());
            break;
        }
    case TnsCString:
        {
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aOther).get_nsCString());
            break;
        }
    case TnsIURI:
        {
            new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>((aOther).get_nsIURI());
            break;
        }
    case TnsIPrincipal:
        {
            new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>((aOther).get_nsIPrincipal());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPDLVariantValue::IPDLVariantValue(IPDLVariantValue&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tbool:
        {
            new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aOther).get_bool()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tuint8_t:
        {
            new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move((aOther).get_uint8_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tint16_t:
        {
            new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move((aOther).get_int16_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tuint16_t:
        {
            new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move((aOther).get_uint16_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tint32_t:
        {
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aOther).get_int32_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tuint32_t:
        {
            new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move((aOther).get_uint32_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aOther).get_float()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tdouble:
        {
            new (mozilla::KnownNotNull, ptr_double()) double(std::move((aOther).get_double()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsID:
        {
            new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move((aOther).get_nsID()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsString:
        {
            new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aOther).get_nsString()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsCString:
        {
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aOther).get_nsCString()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsIURI:
        {
            new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move((aOther).get_nsIURI()));
            (aOther).MaybeDestroy();
            break;
        }
    case TnsIPrincipal:
        {
            new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move((aOther).get_nsIPrincipal()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto IPDLVariantValue::operator=(const bool& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_bool()) bool(aRhs);
    mType = Tbool;
    return (*(this));
}

auto IPDLVariantValue::operator=(bool&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aRhs));
    mType = Tbool;
    return (*(this));
}

auto IPDLVariantValue::operator=(const uint8_t& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(aRhs);
    mType = Tuint8_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(uint8_t&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move(aRhs));
    mType = Tuint8_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(const int16_t& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(aRhs);
    mType = Tint16_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(int16_t&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move(aRhs));
    mType = Tint16_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(const uint16_t& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(aRhs);
    mType = Tuint16_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(uint16_t&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move(aRhs));
    mType = Tuint16_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(const int32_t& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(aRhs);
    mType = Tint32_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(int32_t&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move(aRhs));
    mType = Tint32_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(const uint32_t& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(aRhs);
    mType = Tuint32_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(uint32_t&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move(aRhs));
    mType = Tuint32_t;
    return (*(this));
}

auto IPDLVariantValue::operator=(const float& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_float()) float(aRhs);
    mType = Tfloat;
    return (*(this));
}

auto IPDLVariantValue::operator=(float&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_float()) float(std::move(aRhs));
    mType = Tfloat;
    return (*(this));
}

auto IPDLVariantValue::operator=(const double& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_double()) double(aRhs);
    mType = Tdouble;
    return (*(this));
}

auto IPDLVariantValue::operator=(double&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_double()) double(std::move(aRhs));
    mType = Tdouble;
    return (*(this));
}

auto IPDLVariantValue::operator=(const nsID& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsID()) nsID(aRhs);
    mType = TnsID;
    return (*(this));
}

auto IPDLVariantValue::operator=(nsID&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move(aRhs));
    mType = TnsID;
    return (*(this));
}

auto IPDLVariantValue::operator=(const nsString& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(aRhs);
    mType = TnsString;
    return (*(this));
}

auto IPDLVariantValue::operator=(nsString&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move(aRhs));
    mType = TnsString;
    return (*(this));
}

auto IPDLVariantValue::operator=(const nsCString& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(aRhs);
    mType = TnsCString;
    return (*(this));
}

auto IPDLVariantValue::operator=(nsCString&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move(aRhs));
    mType = TnsCString;
    return (*(this));
}

auto IPDLVariantValue::operator=(nsIURI* aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(aRhs);
    mType = TnsIURI;
    return (*(this));
}

auto IPDLVariantValue::operator=(RefPtr<nsIURI>&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move(aRhs));
    mType = TnsIURI;
    return (*(this));
}

auto IPDLVariantValue::operator=(nsIPrincipal* aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(aRhs);
    mType = TnsIPrincipal;
    return (*(this));
}

auto IPDLVariantValue::operator=(RefPtr<nsIPrincipal>&& aRhs) -> IPDLVariantValue&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move(aRhs));
    mType = TnsIPrincipal;
    return (*(this));
}

auto IPDLVariantValue::operator=(const IPDLVariantValue& aRhs) -> IPDLVariantValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tbool:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_bool()) bool((aRhs).get_bool());
            break;
        }
    case Tuint8_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t((aRhs).get_uint8_t());
            break;
        }
    case Tint16_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int16_t()) int16_t((aRhs).get_int16_t());
            break;
        }
    case Tuint16_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t((aRhs).get_uint16_t());
            break;
        }
    case Tint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t((aRhs).get_int32_t());
            break;
        }
    case Tuint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t((aRhs).get_uint32_t());
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float((aRhs).get_float());
            break;
        }
    case Tdouble:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_double()) double((aRhs).get_double());
            break;
        }
    case TnsID:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsID()) nsID((aRhs).get_nsID());
            break;
        }
    case TnsString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsString()) nsString((aRhs).get_nsString());
            break;
        }
    case TnsCString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString((aRhs).get_nsCString());
            break;
        }
    case TnsIURI:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>((aRhs).get_nsIURI());
            break;
        }
    case TnsIPrincipal:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>((aRhs).get_nsIPrincipal());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPDLVariantValue::operator=(IPDLVariantValue&& aRhs) -> IPDLVariantValue&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tbool:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aRhs).get_bool()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tuint8_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint8_t()) uint8_t(std::move((aRhs).get_uint8_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tint16_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int16_t()) int16_t(std::move((aRhs).get_int16_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tuint16_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint16_t()) uint16_t(std::move((aRhs).get_uint16_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_int32_t()) int32_t(std::move((aRhs).get_int32_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tuint32_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_uint32_t()) uint32_t(std::move((aRhs).get_uint32_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tfloat:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_float()) float(std::move((aRhs).get_float()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tdouble:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_double()) double(std::move((aRhs).get_double()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsID:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsID()) nsID(std::move((aRhs).get_nsID()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsString()) nsString(std::move((aRhs).get_nsString()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsCString:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsCString()) nsCString(std::move((aRhs).get_nsCString()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsIURI:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsIURI()) RefPtr<nsIURI>(std::move((aRhs).get_nsIURI()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TnsIPrincipal:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsIPrincipal()) RefPtr<nsIPrincipal>(std::move((aRhs).get_nsIPrincipal()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tbool:
        {
            IPC::WriteParam(aWriter, (aVar).get_bool());
            // Sentinel = 'Tbool'
            (aWriter)->WriteSentinel(96993793);
            return;
        }
    case union__::Tuint8_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_uint8_t());
            // Sentinel = 'Tuint8_t'
            (aWriter)->WriteSentinel(237044512);
            return;
        }
    case union__::Tint16_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_int16_t());
            // Sentinel = 'Tint16_t'
            (aWriter)->WriteSentinel(217514714);
            return;
        }
    case union__::Tuint16_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_uint16_t());
            // Sentinel = 'Tuint16_t'
            (aWriter)->WriteSentinel(284427087);
            return;
        }
    case union__::Tint32_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_int32_t());
            // Sentinel = 'Tint32_t'
            (aWriter)->WriteSentinel(217252568);
            return;
        }
    case union__::Tuint32_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_uint32_t());
            // Sentinel = 'Tuint32_t'
            (aWriter)->WriteSentinel(284164941);
            return;
        }
    case union__::Tfloat:
        {
            IPC::WriteParam(aWriter, (aVar).get_float());
            // Sentinel = 'Tfloat'
            (aWriter)->WriteSentinel(137298539);
            return;
        }
    case union__::Tdouble:
        {
            IPC::WriteParam(aWriter, (aVar).get_double());
            // Sentinel = 'Tdouble'
            (aWriter)->WriteSentinel(185402064);
            return;
        }
    case union__::TnsID:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsID());
            // Sentinel = 'TnsID'
            (aWriter)->WriteSentinel(93323715);
            return;
        }
    case union__::TnsString:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsString());
            // Sentinel = 'TnsString'
            (aWriter)->WriteSentinel(302908333);
            return;
        }
    case union__::TnsCString:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsCString());
            // Sentinel = 'TnsCString'
            (aWriter)->WriteSentinel(353960944);
            return;
        }
    case union__::TnsIURI:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsIURI());
            // Sentinel = 'TnsIURI'
            (aWriter)->WriteSentinel(171311727);
            return;
        }
    case union__::TnsIPrincipal:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsIPrincipal());
            // Sentinel = 'TnsIPrincipal'
            (aWriter)->WriteSentinel(589825313);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPDLVariantValue");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::Tbool:
        {
            auto maybe__tmp = IPC::ReadParam<bool>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tbool of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tbool'
            if ((!((aReader)->ReadSentinel(96993793)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tbool of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tuint8_t:
        {
            auto maybe__tmp = IPC::ReadParam<::uint8_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tuint8_t of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tuint8_t'
            if ((!((aReader)->ReadSentinel(237044512)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuint8_t of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tint16_t:
        {
            auto maybe__tmp = IPC::ReadParam<::int16_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tint16_t of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tint16_t'
            if ((!((aReader)->ReadSentinel(217514714)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tint16_t of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tuint16_t:
        {
            auto maybe__tmp = IPC::ReadParam<::uint16_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tuint16_t of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tuint16_t'
            if ((!((aReader)->ReadSentinel(284427087)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuint16_t of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tint32_t:
        {
            auto maybe__tmp = IPC::ReadParam<::int32_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tint32_t of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tint32_t'
            if ((!((aReader)->ReadSentinel(217252568)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tint32_t of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tuint32_t:
        {
            auto maybe__tmp = IPC::ReadParam<::uint32_t>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tuint32_t of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tuint32_t'
            if ((!((aReader)->ReadSentinel(284164941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuint32_t of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tfloat:
        {
            auto maybe__tmp = IPC::ReadParam<float>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tfloat of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tfloat'
            if ((!((aReader)->ReadSentinel(137298539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tfloat of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tdouble:
        {
            auto maybe__tmp = IPC::ReadParam<double>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tdouble of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'Tdouble'
            if ((!((aReader)->ReadSentinel(185402064)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tdouble of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsID:
        {
            auto maybe__tmp = IPC::ReadParam<::nsID>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsID of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsID'
            if ((!((aReader)->ReadSentinel(93323715)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsID of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsString:
        {
            auto maybe__tmp = IPC::ReadParam<::nsString>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsString of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsString'
            if ((!((aReader)->ReadSentinel(302908333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsString of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsCString:
        {
            auto maybe__tmp = IPC::ReadParam<::nsCString>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsCString of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsCString'
            if ((!((aReader)->ReadSentinel(353960944)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsCString of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsIURI:
        {
            auto maybe__tmp = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsIURI of union IPDLVariantValue");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TnsIURI'
            if ((!((aReader)->ReadSentinel(171311727)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TnsIURI of union IPDLVariantValue");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TnsIPrincipal:
        {
            auto maybe__tmp = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TnsIPrincipal of union IPDLVariantValue");
                return {};

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::IDPLVariant>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    (aWriter)->WriteBytes((&((aVar).type())), 4);
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
}

auto ParamTraits<::mozilla::dom::IDPLVariant>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___data = IPC::ReadParam<::mozilla::dom::IPDLVariantValue>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (IPDLVariantValue) member of 'IDPLVariant'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (IPDLVariantValue) member of 'IDPLVariant'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            std::move(_data)};
    if ((!((aReader)->ReadBytesInto((&((result__)->type())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPDLProperty'");
        return {};
    }
    auto maybe___value = IPC::ReadParam<RefPtr<::nsIVariant>>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (nsIVariant) member of 'IPDLProperty'");
        return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ParentShowInfo|
//
namespace mozilla {
namespace dom {
auto ParentShowInfo::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(ParentShowInfo, widgetRounding_) - offsetof(ParentShowInfo, dpi_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentShowInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).fakeShowInfo());
    // Sentinel = 'fakeShowInfo'
    (aWriter)->WriteSentinel(515900613);
    IPC::WriteParam(aWriter, (aVar).isTransparent());
    // Sentinel = 'isTransparent'
    (aWriter)->WriteSentinel(631244143);
    (aWriter)->WriteBytes((&((aVar).defaultScale())), 8);
    // Sentinel = 'defaultScale'
    (aWriter)->WriteSentinel(525796558);
    (aWriter)->WriteBytes((&((aVar).dpi())), 8);
    // Sentinel = 'dpi | widgetRounding'
    (aWriter)->WriteSentinel(1322977220);
}

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

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'ParentShowInfo'");
        return {};
    }
    auto maybe___fakeShowInfo = IPC::ReadParam<bool>(aReader);
    if (!maybe___fakeShowInfo) {
        aReader->FatalError("Error deserializing 'fakeShowInfo' (bool) member of 'ParentShowInfo'");
        return {};

    }
    auto& _fakeShowInfo = *maybe___fakeShowInfo;
    // Sentinel = 'fakeShowInfo'
    if ((!((aReader)->ReadSentinel(515900613)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fakeShowInfo' (bool) member of 'ParentShowInfo'");
        return {};
    }
    auto maybe___isTransparent = IPC::ReadParam<bool>(aReader);
    if (!maybe___isTransparent) {
        aReader->FatalError("Error deserializing 'isTransparent' (bool) member of 'ParentShowInfo'");
        return {};

    }
    auto& _isTransparent = *maybe___isTransparent;
    // Sentinel = 'isTransparent'
    if ((!((aReader)->ReadSentinel(631244143)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isTransparent' (bool) member of 'ParentShowInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_name),
            std::move(_fakeShowInfo),
            std::move(_isTransparent),
            float{0},
            ::int32_t{0},
            double{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->defaultScale())), 8)))) {
        aReader->FatalError("Error bulk reading fields from double");
        return {};
    }
    // Sentinel = 'defaultScale'
    if ((!((aReader)->ReadSentinel(525796558)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from double");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->dpi())), 8)))) {
        aReader->FatalError("Error bulk reading fields from float");
        return {};
    }
    // Sentinel = 'dpi | widgetRounding'
    if ((!((aReader)->ReadSentinel(1322977220)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from float");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::OwnerShowInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).size());
    // Sentinel = 'size'
    (aWriter)->WriteSentinel(73662908);
    IPC::WriteParam(aWriter, (aVar).scrollbarPreference());
    // Sentinel = 'scrollbarPreference'
    (aWriter)->WriteSentinel(1316030404);
    IPC::WriteParam(aWriter, (aVar).sizeMode());
    // Sentinel = 'sizeMode'
    (aWriter)->WriteSentinel(251790145);
}

auto ParamTraits<::mozilla::dom::OwnerShowInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___size = IPC::ReadParam<::mozilla::LayoutDeviceIntSize>(aReader);
    if (!maybe___size) {
        aReader->FatalError("Error deserializing 'size' (LayoutDeviceIntSize) member of 'OwnerShowInfo'");
        return {};

    }
    auto& _size = *maybe___size;
    // Sentinel = 'size'
    if ((!((aReader)->ReadSentinel(73662908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (LayoutDeviceIntSize) member of 'OwnerShowInfo'");
        return {};
    }
    auto maybe___scrollbarPreference = IPC::ReadParam<::mozilla::ScrollbarPreference>(aReader);
    if (!maybe___scrollbarPreference) {
        aReader->FatalError("Error deserializing 'scrollbarPreference' (ScrollbarPreference) member of 'OwnerShowInfo'");
        return {};

    }
    auto& _scrollbarPreference = *maybe___scrollbarPreference;
    // Sentinel = 'scrollbarPreference'
    if ((!((aReader)->ReadSentinel(1316030404)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scrollbarPreference' (ScrollbarPreference) member of 'OwnerShowInfo'");
        return {};
    }
    auto maybe___sizeMode = IPC::ReadParam<::nsSizeMode>(aReader);
    if (!maybe___sizeMode) {
        aReader->FatalError("Error deserializing 'sizeMode' (nsSizeMode) member of 'OwnerShowInfo'");
        return {};

    }
    auto& _sizeMode = *maybe___sizeMode;
    // Sentinel = 'sizeMode'
    if ((!((aReader)->ReadSentinel(251790145)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sizeMode' (nsSizeMode) member of 'OwnerShowInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_size),
            std::move(_scrollbarPreference),
            std::move(_sizeMode)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCImage>::Write(
        IPC::MessageWriter* aWriter,
        paramType&& aVar) -> void
{
    IPC::WriteParam(aWriter, std::move((aVar).data()));
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    IPC::WriteParam(aWriter, (aVar).format());
    // Sentinel = 'format'
    (aWriter)->WriteSentinel(148505226);
    IPC::WriteParam(aWriter, (aVar).size());
    // Sentinel = 'size'
    (aWriter)->WriteSentinel(73662908);
    (aWriter)->WriteBytes((&((aVar).stride())), 4);
    // Sentinel = 'stride'
    (aWriter)->WriteSentinel(153879180);
}

auto ParamTraits<::mozilla::dom::IPCImage>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___data = IPC::ReadParam<::mozilla::ipc::BigBuffer>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (BigBuffer) member of 'IPCImage'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (BigBuffer) member of 'IPCImage'");
        return {};
    }
    auto maybe___format = IPC::ReadParam<::mozilla::gfx::SurfaceFormat>(aReader);
    if (!maybe___format) {
        aReader->FatalError("Error deserializing 'format' (SurfaceFormat) member of 'IPCImage'");
        return {};

    }
    auto& _format = *maybe___format;
    // Sentinel = 'format'
    if ((!((aReader)->ReadSentinel(148505226)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'IPCImage'");
        return {};
    }
    auto maybe___size = IPC::ReadParam<::mozilla::ImageIntSize>(aReader);
    if (!maybe___size) {
        aReader->FatalError("Error deserializing 'size' (ImageIntSize) member of 'IPCImage'");
        return {};

    }
    auto& _size = *maybe___size;
    // Sentinel = 'size'
    if ((!((aReader)->ReadSentinel(73662908)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (ImageIntSize) member of 'IPCImage'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_data),
            ::uint32_t{0},
            std::move(_format),
            std::move(_size)};
    if ((!((aReader)->ReadBytesInto((&((result__)->stride())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'stride'
    if ((!((aReader)->ReadSentinel(153879180)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCNotificationAction>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).title());
    // Sentinel = 'title'
    (aWriter)->WriteSentinel(109445667);
}

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

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPCNotificationAction'");
        return {};
    }
    auto maybe___title = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___title) {
        aReader->FatalError("Error deserializing 'title' (nsString) member of 'IPCNotificationAction'");
        return {};

    }
    auto& _title = *maybe___title;
    // Sentinel = 'title'
    if ((!((aReader)->ReadSentinel(109445667)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'title' (nsString) member of 'IPCNotificationAction'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_name),
            std::move(_title)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCNotificationOptions>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).title());
    // Sentinel = 'title'
    (aWriter)->WriteSentinel(109445667);
    IPC::WriteParam(aWriter, (aVar).dir());
    // Sentinel = 'dir'
    (aWriter)->WriteSentinel(41091392);
    IPC::WriteParam(aWriter, (aVar).lang());
    // Sentinel = 'lang'
    (aWriter)->WriteSentinel(68813219);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).tag());
    // Sentinel = 'tag'
    (aWriter)->WriteSentinel(42467645);
    IPC::WriteParam(aWriter, (aVar).icon());
    // Sentinel = 'icon'
    (aWriter)->WriteSentinel(69009834);
    IPC::WriteParam(aWriter, (aVar).requireInteraction());
    // Sentinel = 'requireInteraction'
    (aWriter)->WriteSentinel(1196361598);
    IPC::WriteParam(aWriter, (aVar).silent());
    // Sentinel = 'silent'
    (aWriter)->WriteSentinel(150209168);
    IPC::WriteParam(aWriter, (aVar).vibrate());
    // Sentinel = 'vibrate'
    (aWriter)->WriteSentinel(198771438);
    IPC::WriteParam(aWriter, (aVar).dataSerialized());
    // Sentinel = 'dataSerialized'
    (aWriter)->WriteSentinel(703202727);
    IPC::WriteParam(aWriter, (aVar).actions());
    // Sentinel = 'actions'
    (aWriter)->WriteSentinel(193200882);
}

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

    }
    auto& _title = *maybe___title;
    // Sentinel = 'title'
    if ((!((aReader)->ReadSentinel(109445667)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'title' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___dir = IPC::ReadParam<::mozilla::dom::NotificationDirection>(aReader);
    if (!maybe___dir) {
        aReader->FatalError("Error deserializing 'dir' (NotificationDirection) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _dir = *maybe___dir;
    // Sentinel = 'dir'
    if ((!((aReader)->ReadSentinel(41091392)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dir' (NotificationDirection) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___lang = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___lang) {
        aReader->FatalError("Error deserializing 'lang' (nsString) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _lang = *maybe___lang;
    // Sentinel = 'lang'
    if ((!((aReader)->ReadSentinel(68813219)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lang' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (nsString) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___tag = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___tag) {
        aReader->FatalError("Error deserializing 'tag' (nsString) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _tag = *maybe___tag;
    // Sentinel = 'tag'
    if ((!((aReader)->ReadSentinel(42467645)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'tag' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___icon = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___icon) {
        aReader->FatalError("Error deserializing 'icon' (nsString) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _icon = *maybe___icon;
    // Sentinel = 'icon'
    if ((!((aReader)->ReadSentinel(69009834)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'icon' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___requireInteraction = IPC::ReadParam<bool>(aReader);
    if (!maybe___requireInteraction) {
        aReader->FatalError("Error deserializing 'requireInteraction' (bool) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _requireInteraction = *maybe___requireInteraction;
    // Sentinel = 'requireInteraction'
    if ((!((aReader)->ReadSentinel(1196361598)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requireInteraction' (bool) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___silent = IPC::ReadParam<bool>(aReader);
    if (!maybe___silent) {
        aReader->FatalError("Error deserializing 'silent' (bool) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _silent = *maybe___silent;
    // Sentinel = 'silent'
    if ((!((aReader)->ReadSentinel(150209168)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'silent' (bool) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___vibrate = IPC::ReadParam<nsTArray<::uint32_t>>(aReader);
    if (!maybe___vibrate) {
        aReader->FatalError("Error deserializing 'vibrate' (uint32_t[]) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _vibrate = *maybe___vibrate;
    // Sentinel = 'vibrate'
    if ((!((aReader)->ReadSentinel(198771438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'vibrate' (uint32_t[]) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___dataSerialized = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___dataSerialized) {
        aReader->FatalError("Error deserializing 'dataSerialized' (nsString) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _dataSerialized = *maybe___dataSerialized;
    // Sentinel = 'dataSerialized'
    if ((!((aReader)->ReadSentinel(703202727)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dataSerialized' (nsString) member of 'IPCNotificationOptions'");
        return {};
    }
    auto maybe___actions = IPC::ReadParam<nsTArray<::mozilla::dom::IPCNotificationAction>>(aReader);
    if (!maybe___actions) {
        aReader->FatalError("Error deserializing 'actions' (IPCNotificationAction[]) member of 'IPCNotificationOptions'");
        return {};

    }
    auto& _actions = *maybe___actions;
    // Sentinel = 'actions'
    if ((!((aReader)->ReadSentinel(193200882)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'actions' (IPCNotificationAction[]) member of 'IPCNotificationOptions'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_title),
            std::move(_dir),
            std::move(_lang),
            std::move(_body),
            std::move(_tag),
            std::move(_icon),
            std::move(_requireInteraction),
            std::move(_silent),
            std::move(_vibrate),
            std::move(_dataSerialized),
            std::move(_actions)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::IPCNotification>::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 'IPCNotification'");
        return {};

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

    }
    auto& _options = *maybe___options;
    // Sentinel = 'options'
    if ((!((aReader)->ReadSentinel(204735245)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'options' (IPCNotificationOptions) member of 'IPCNotification'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_id),
            std::move(_options)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCNotificationsOrError|
//
namespace mozilla {
namespace dom {
auto IPCNotificationsOrError::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TArrayOfIPCNotification:
        {
            (ptr_ArrayOfIPCNotification())->~ArrayOfIPCNotification__tdef();
            break;
        }
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(const nsTArray<IPCNotification>& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>((aOther).Clone());
    mType = TArrayOfIPCNotification;
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(nsTArray<IPCNotification>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(std::move(aOther));
    mType = TArrayOfIPCNotification;
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(const nsresult& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
    mType = Tnsresult;
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(nsresult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
    mType = Tnsresult;
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(const IPCNotificationsOrError& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TArrayOfIPCNotification:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(((aOther).get_ArrayOfIPCNotification()).Clone());
            break;
        }
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCNotificationsOrError::IPCNotificationsOrError(IPCNotificationsOrError&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TArrayOfIPCNotification:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(std::move((aOther).get_ArrayOfIPCNotification()));
            (aOther).MaybeDestroy();
            break;
        }
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto IPCNotificationsOrError::operator=(const nsTArray<IPCNotification>& aRhs) -> IPCNotificationsOrError&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>((aRhs).Clone());
    mType = TArrayOfIPCNotification;
    return (*(this));
}

auto IPCNotificationsOrError::operator=(nsTArray<IPCNotification>&& aRhs) -> IPCNotificationsOrError&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(std::move(aRhs));
    mType = TArrayOfIPCNotification;
    return (*(this));
}

auto IPCNotificationsOrError::operator=(const nsresult& aRhs) -> IPCNotificationsOrError&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
    mType = Tnsresult;
    return (*(this));
}

auto IPCNotificationsOrError::operator=(nsresult&& aRhs) -> IPCNotificationsOrError&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
    mType = Tnsresult;
    return (*(this));
}

auto IPCNotificationsOrError::operator=(const IPCNotificationsOrError& aRhs) -> IPCNotificationsOrError&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TArrayOfIPCNotification:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(((aRhs).get_ArrayOfIPCNotification()).Clone());
            break;
        }
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCNotificationsOrError::operator=(IPCNotificationsOrError&& aRhs) -> IPCNotificationsOrError&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TArrayOfIPCNotification:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfIPCNotification()) nsTArray<IPCNotification>(std::move((aRhs).get_ArrayOfIPCNotification()));
            (aRhs).MaybeDestroy();
            break;
        }
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TArrayOfIPCNotification:
        {
            IPC::WriteParam(aWriter, (aVar).get_ArrayOfIPCNotification());
            // Sentinel = 'TArrayOfIPCNotification'
            (aWriter)->WriteSentinel(1713375436);
            return;
        }
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPCNotificationsOrError");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TArrayOfIPCNotification:
        {
            auto maybe__tmp = IPC::ReadParam<nsTArray<::mozilla::dom::IPCNotification>>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TArrayOfIPCNotification of union IPCNotificationsOrError");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TArrayOfIPCNotification'
            if ((!((aReader)->ReadSentinel(1713375436)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TArrayOfIPCNotification of union IPCNotificationsOrError");
                return {};
            }
            return std::move(tmp);
        }
    case union__::Tnsresult:
        {
            auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant Tnsresult of union IPCNotificationsOrError");
                return {};

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

} // namespace IPC