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


#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/dom/FetchTypes.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 HeadersEntry|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::HeadersEntry>::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::HeadersEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___name = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___name) {
        aReader->FatalError("Error deserializing 'name' (nsCString) member of 'HeadersEntry'");
        return {};

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

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeadersEntry'");
        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 ParentToParentStream|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ParentToChildStream|
//
namespace mozilla {
namespace dom {
auto ParentToChildStream::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TRemoteLazyInputStream:
        {
            (ptr_RemoteLazyInputStream())->~RemoteLazyInputStream__tdef();
            break;
        }
    case TIPCStream:
        {
            (ptr_IPCStream())->~IPCStream__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(RemoteLazyInputStream* aOther)
{
    new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(aOther);
    mType = TRemoteLazyInputStream;
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(RefPtr<RemoteLazyInputStream>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move(aOther));
    mType = TRemoteLazyInputStream;
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(const IPCStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(aOther);
    mType = TIPCStream;
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(IPCStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move(aOther));
    mType = TIPCStream;
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(const ParentToChildStream& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TRemoteLazyInputStream:
        {
            new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>((aOther).get_RemoteLazyInputStream());
            break;
        }
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aOther).get_IPCStream());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ParentToChildStream::ParentToChildStream(ParentToChildStream&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TRemoteLazyInputStream:
        {
            new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move((aOther).get_RemoteLazyInputStream()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aOther).get_IPCStream()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ParentToChildStream::operator=(RemoteLazyInputStream* aRhs) -> ParentToChildStream&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(aRhs);
    mType = TRemoteLazyInputStream;
    return (*(this));
}

auto ParentToChildStream::operator=(RefPtr<RemoteLazyInputStream>&& aRhs) -> ParentToChildStream&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move(aRhs));
    mType = TRemoteLazyInputStream;
    return (*(this));
}

auto ParentToChildStream::operator=(const IPCStream& aRhs) -> ParentToChildStream&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(aRhs);
    mType = TIPCStream;
    return (*(this));
}

auto ParentToChildStream::operator=(IPCStream&& aRhs) -> ParentToChildStream&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move(aRhs));
    mType = TIPCStream;
    return (*(this));
}

auto ParentToChildStream::operator=(const ParentToChildStream& aRhs) -> ParentToChildStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TRemoteLazyInputStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>((aRhs).get_RemoteLazyInputStream());
            break;
        }
    case TIPCStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aRhs).get_IPCStream());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto ParentToChildStream::operator=(ParentToChildStream&& aRhs) -> ParentToChildStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TRemoteLazyInputStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_RemoteLazyInputStream()) RefPtr<RemoteLazyInputStream>(std::move((aRhs).get_RemoteLazyInputStream()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aRhs).get_IPCStream()));
            (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::ParentToChildStream>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ParentToChildStream union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ParentToChildStream'
    (aWriter)->WriteSentinel(1242761086);

    switch (type) {
    case union__::TRemoteLazyInputStream:
        {
            IPC::WriteParam(aWriter, (aVar).get_RemoteLazyInputStream());
            // Sentinel = 'TRemoteLazyInputStream'
            (aWriter)->WriteSentinel(1677986013);
            return;
        }
    case union__::TIPCStream:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCStream());
            // Sentinel = 'TIPCStream'
            (aWriter)->WriteSentinel(311690141);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ParentToChildStream");
            return;
        }
    }
}

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

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

    switch (type) {
    case union__::TRemoteLazyInputStream:
        {
            auto maybe__tmp = IPC::ReadParam<RefPtr<::mozilla::RemoteLazyInputStream>>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TRemoteLazyInputStream of union ParentToChildStream");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TRemoteLazyInputStream'
            if ((!((aReader)->ReadSentinel(1677986013)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TRemoteLazyInputStream of union ParentToChildStream");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCStream:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::IPCStream>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCStream of union ParentToChildStream");
                return {};

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

} // namespace IPC

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

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

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

    }
    auto& _stream = *maybe___stream;
    // Sentinel = 'stream'
    if ((!((aReader)->ReadSentinel(153223821)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCStream) member of 'ChildToParentStream'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_stream)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union BodyStreamVariant|
//
namespace mozilla {
namespace dom {
auto BodyStreamVariant::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TParentToParentStream:
        {
            (ptr_ParentToParentStream())->~ParentToParentStream__tdef();
            break;
        }
    case TParentToChildStream:
        {
            (ptr_ParentToChildStream())->~ParentToChildStream__tdef();
            break;
        }
    case TChildToParentStream:
        {
            (ptr_ChildToParentStream())->~ChildToParentStream__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ParentToParentStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(aOther);
    mType = TParentToParentStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ParentToParentStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move(aOther));
    mType = TParentToParentStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ParentToChildStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(aOther);
    mType = TParentToChildStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ParentToChildStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move(aOther));
    mType = TParentToChildStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const ChildToParentStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(aOther);
    mType = TChildToParentStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(ChildToParentStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move(aOther));
    mType = TChildToParentStream;
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(const BodyStreamVariant& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TParentToParentStream:
        {
            new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream((aOther).get_ParentToParentStream());
            break;
        }
    case TParentToChildStream:
        {
            new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream((aOther).get_ParentToChildStream());
            break;
        }
    case TChildToParentStream:
        {
            new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream((aOther).get_ChildToParentStream());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT BodyStreamVariant::BodyStreamVariant(BodyStreamVariant&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TParentToParentStream:
        {
            new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move((aOther).get_ParentToParentStream()));
            (aOther).MaybeDestroy();
            break;
        }
    case TParentToChildStream:
        {
            new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move((aOther).get_ParentToChildStream()));
            (aOther).MaybeDestroy();
            break;
        }
    case TChildToParentStream:
        {
            new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move((aOther).get_ChildToParentStream()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto BodyStreamVariant::operator=(const ParentToParentStream& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(aRhs);
    mType = TParentToParentStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(ParentToParentStream&& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move(aRhs));
    mType = TParentToParentStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(const ParentToChildStream& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(aRhs);
    mType = TParentToChildStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(ParentToChildStream&& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move(aRhs));
    mType = TParentToChildStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(const ChildToParentStream& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(aRhs);
    mType = TChildToParentStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(ChildToParentStream&& aRhs) -> BodyStreamVariant&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move(aRhs));
    mType = TChildToParentStream;
    return (*(this));
}

auto BodyStreamVariant::operator=(const BodyStreamVariant& aRhs) -> BodyStreamVariant&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TParentToParentStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream((aRhs).get_ParentToParentStream());
            break;
        }
    case TParentToChildStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream((aRhs).get_ParentToChildStream());
            break;
        }
    case TChildToParentStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream((aRhs).get_ChildToParentStream());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto BodyStreamVariant::operator=(BodyStreamVariant&& aRhs) -> BodyStreamVariant&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TParentToParentStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToParentStream()) ParentToParentStream(std::move((aRhs).get_ParentToParentStream()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TParentToChildStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToChildStream()) ParentToChildStream(std::move((aRhs).get_ParentToChildStream()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TChildToParentStream:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ChildToParentStream()) ChildToParentStream(std::move((aRhs).get_ChildToParentStream()));
            (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::BodyStreamVariant>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::BodyStreamVariant union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'BodyStreamVariant'
    (aWriter)->WriteSentinel(1008600784);

    switch (type) {
    case union__::TParentToParentStream:
        {
            IPC::WriteParam(aWriter, (aVar).get_ParentToParentStream());
            // Sentinel = 'TParentToParentStream'
            (aWriter)->WriteSentinel(1508903000);
            return;
        }
    case union__::TParentToChildStream:
        {
            IPC::WriteParam(aWriter, (aVar).get_ParentToChildStream());
            // Sentinel = 'TParentToChildStream'
            (aWriter)->WriteSentinel(1352927186);
            return;
        }
    case union__::TChildToParentStream:
        {
            IPC::WriteParam(aWriter, (aVar).get_ChildToParentStream());
            // Sentinel = 'TChildToParentStream'
            (aWriter)->WriteSentinel(1335953362);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union BodyStreamVariant");
            return;
        }
    }
}

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

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCInternalRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).method());
    // Sentinel = 'method'
    (aWriter)->WriteSentinel(148308610);
    IPC::WriteParam(aWriter, (aVar).urlList());
    // Sentinel = 'urlList'
    (aWriter)->WriteSentinel(197591792);
    IPC::WriteParam(aWriter, (aVar).headersGuard());
    // Sentinel = 'headersGuard'
    (aWriter)->WriteSentinel(522912976);
    IPC::WriteParam(aWriter, (aVar).headers());
    // Sentinel = 'headers'
    (aWriter)->WriteSentinel(188220125);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).preferredAlternativeDataType());
    // Sentinel = 'preferredAlternativeDataType'
    (aWriter)->WriteSentinel(2781023067);
    IPC::WriteParam(aWriter, (aVar).contentPolicyType());
    // Sentinel = 'contentPolicyType'
    (aWriter)->WriteSentinel(1066927886);
    IPC::WriteParam(aWriter, (aVar).referrer());
    // Sentinel = 'referrer'
    (aWriter)->WriteSentinel(252838750);
    IPC::WriteParam(aWriter, (aVar).referrerPolicy());
    // Sentinel = 'referrerPolicy'
    (aWriter)->WriteSentinel(729482702);
    IPC::WriteParam(aWriter, (aVar).environmentReferrerPolicy());
    // Sentinel = 'environmentReferrerPolicy'
    (aWriter)->WriteSentinel(2278427235);
    IPC::WriteParam(aWriter, (aVar).requestMode());
    // Sentinel = 'requestMode'
    (aWriter)->WriteSentinel(468386959);
    IPC::WriteParam(aWriter, (aVar).requestCredentials());
    // Sentinel = 'requestCredentials'
    (aWriter)->WriteSentinel(1194461048);
    IPC::WriteParam(aWriter, (aVar).cacheMode());
    // Sentinel = 'cacheMode'
    (aWriter)->WriteSentinel(290980730);
    IPC::WriteParam(aWriter, (aVar).requestRedirect());
    // Sentinel = 'requestRedirect'
    (aWriter)->WriteSentinel(843974204);
    IPC::WriteParam(aWriter, (aVar).requestPriority());
    // Sentinel = 'requestPriority'
    (aWriter)->WriteSentinel(856163948);
    IPC::WriteParam(aWriter, (aVar).integrity());
    // Sentinel = 'integrity'
    (aWriter)->WriteSentinel(320537568);
    IPC::WriteParam(aWriter, (aVar).keepalive());
    // Sentinel = 'keepalive'
    (aWriter)->WriteSentinel(309855159);
    IPC::WriteParam(aWriter, (aVar).fragment());
    // Sentinel = 'fragment'
    (aWriter)->WriteSentinel(248644437);
    IPC::WriteParam(aWriter, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aWriter)->WriteSentinel(633472335);
    IPC::WriteParam(aWriter, (aVar).interceptionTriggeringPrincipalInfo());
    // Sentinel = 'interceptionTriggeringPrincipalInfo'
    (aWriter)->WriteSentinel(82710101);
    IPC::WriteParam(aWriter, (aVar).interceptionContentPolicyType());
    // Sentinel = 'interceptionContentPolicyType'
    (aWriter)->WriteSentinel(3032288258);
    IPC::WriteParam(aWriter, (aVar).interceptionRedirectChain());
    // Sentinel = 'interceptionRedirectChain'
    (aWriter)->WriteSentinel(2251754026);
    IPC::WriteParam(aWriter, (aVar).interceptionFromThirdParty());
    // Sentinel = 'interceptionFromThirdParty'
    (aWriter)->WriteSentinel(2433813172);
    IPC::WriteParam(aWriter, (aVar).embedderPolicy());
    // Sentinel = 'embedderPolicy'
    (aWriter)->WriteSentinel(703792553);
    (aWriter)->WriteBytes((&((aVar).bodySize())), 8);
    // Sentinel = 'bodySize'
    (aWriter)->WriteSentinel(246809418);
    (aWriter)->WriteBytes((&((aVar).internalPriority())), 4);
    // Sentinel = 'internalPriority'
    (aWriter)->WriteSentinel(953550528);
}

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

    }
    auto& _method = *maybe___method;
    // Sentinel = 'method'
    if ((!((aReader)->ReadSentinel(148308610)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'method' (nsCString) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___urlList = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
    if (!maybe___urlList) {
        aReader->FatalError("Error deserializing 'urlList' (nsCString[]) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _urlList = *maybe___urlList;
    // Sentinel = 'urlList'
    if ((!((aReader)->ReadSentinel(197591792)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlList' (nsCString[]) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
    if (!maybe___headersGuard) {
        aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _headersGuard = *maybe___headersGuard;
    // Sentinel = 'headersGuard'
    if ((!((aReader)->ReadSentinel(522912976)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::HeadersEntry>>(aReader);
    if (!maybe___headers) {
        aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _headers = *maybe___headers;
    // Sentinel = 'headers'
    if ((!((aReader)->ReadSentinel(188220125)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::BodyStreamVariant>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (BodyStreamVariant?) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (BodyStreamVariant?) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___preferredAlternativeDataType = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___preferredAlternativeDataType) {
        aReader->FatalError("Error deserializing 'preferredAlternativeDataType' (nsCString) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _preferredAlternativeDataType = *maybe___preferredAlternativeDataType;
    // Sentinel = 'preferredAlternativeDataType'
    if ((!((aReader)->ReadSentinel(2781023067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preferredAlternativeDataType' (nsCString) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
    if (!maybe___contentPolicyType) {
        aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _contentPolicyType = *maybe___contentPolicyType;
    // Sentinel = 'contentPolicyType'
    if ((!((aReader)->ReadSentinel(1066927886)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___referrer = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___referrer) {
        aReader->FatalError("Error deserializing 'referrer' (nsCString) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _referrer = *maybe___referrer;
    // Sentinel = 'referrer'
    if ((!((aReader)->ReadSentinel(252838750)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'referrer' (nsCString) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___referrerPolicy = IPC::ReadParam<::mozilla::dom::ReferrerPolicy>(aReader);
    if (!maybe___referrerPolicy) {
        aReader->FatalError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _referrerPolicy = *maybe___referrerPolicy;
    // Sentinel = 'referrerPolicy'
    if ((!((aReader)->ReadSentinel(729482702)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___environmentReferrerPolicy = IPC::ReadParam<::mozilla::dom::ReferrerPolicy>(aReader);
    if (!maybe___environmentReferrerPolicy) {
        aReader->FatalError("Error deserializing 'environmentReferrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _environmentReferrerPolicy = *maybe___environmentReferrerPolicy;
    // Sentinel = 'environmentReferrerPolicy'
    if ((!((aReader)->ReadSentinel(2278427235)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'environmentReferrerPolicy' (ReferrerPolicy) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___requestMode = IPC::ReadParam<::mozilla::dom::RequestMode>(aReader);
    if (!maybe___requestMode) {
        aReader->FatalError("Error deserializing 'requestMode' (RequestMode) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _requestMode = *maybe___requestMode;
    // Sentinel = 'requestMode'
    if ((!((aReader)->ReadSentinel(468386959)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestMode' (RequestMode) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___requestCredentials = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
    if (!maybe___requestCredentials) {
        aReader->FatalError("Error deserializing 'requestCredentials' (RequestCredentials) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _requestCredentials = *maybe___requestCredentials;
    // Sentinel = 'requestCredentials'
    if ((!((aReader)->ReadSentinel(1194461048)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestCredentials' (RequestCredentials) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___cacheMode = IPC::ReadParam<::mozilla::dom::RequestCache>(aReader);
    if (!maybe___cacheMode) {
        aReader->FatalError("Error deserializing 'cacheMode' (RequestCache) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _cacheMode = *maybe___cacheMode;
    // Sentinel = 'cacheMode'
    if ((!((aReader)->ReadSentinel(290980730)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheMode' (RequestCache) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___requestRedirect = IPC::ReadParam<::mozilla::dom::RequestRedirect>(aReader);
    if (!maybe___requestRedirect) {
        aReader->FatalError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _requestRedirect = *maybe___requestRedirect;
    // Sentinel = 'requestRedirect'
    if ((!((aReader)->ReadSentinel(843974204)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___requestPriority = IPC::ReadParam<::mozilla::dom::RequestPriority>(aReader);
    if (!maybe___requestPriority) {
        aReader->FatalError("Error deserializing 'requestPriority' (RequestPriority) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _requestPriority = *maybe___requestPriority;
    // Sentinel = 'requestPriority'
    if ((!((aReader)->ReadSentinel(856163948)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestPriority' (RequestPriority) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___integrity = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___integrity) {
        aReader->FatalError("Error deserializing 'integrity' (nsString) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _integrity = *maybe___integrity;
    // Sentinel = 'integrity'
    if ((!((aReader)->ReadSentinel(320537568)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'integrity' (nsString) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___keepalive = IPC::ReadParam<bool>(aReader);
    if (!maybe___keepalive) {
        aReader->FatalError("Error deserializing 'keepalive' (bool) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _keepalive = *maybe___keepalive;
    // Sentinel = 'keepalive'
    if ((!((aReader)->ReadSentinel(309855159)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keepalive' (bool) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___fragment = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___fragment) {
        aReader->FatalError("Error deserializing 'fragment' (nsCString) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _fragment = *maybe___fragment;
    // Sentinel = 'fragment'
    if ((!((aReader)->ReadSentinel(248644437)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fragment' (nsCString) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
    if (!maybe___principalInfo) {
        aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _principalInfo = *maybe___principalInfo;
    // Sentinel = 'principalInfo'
    if ((!((aReader)->ReadSentinel(633472335)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___interceptionTriggeringPrincipalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
    if (!maybe___interceptionTriggeringPrincipalInfo) {
        aReader->FatalError("Error deserializing 'interceptionTriggeringPrincipalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _interceptionTriggeringPrincipalInfo = *maybe___interceptionTriggeringPrincipalInfo;
    // Sentinel = 'interceptionTriggeringPrincipalInfo'
    if ((!((aReader)->ReadSentinel(82710101)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'interceptionTriggeringPrincipalInfo' (PrincipalInfo?) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___interceptionContentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
    if (!maybe___interceptionContentPolicyType) {
        aReader->FatalError("Error deserializing 'interceptionContentPolicyType' (nsContentPolicyType) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _interceptionContentPolicyType = *maybe___interceptionContentPolicyType;
    // Sentinel = 'interceptionContentPolicyType'
    if ((!((aReader)->ReadSentinel(3032288258)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'interceptionContentPolicyType' (nsContentPolicyType) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___interceptionRedirectChain = IPC::ReadParam<nsTArray<::mozilla::net::RedirectHistoryEntryInfo>>(aReader);
    if (!maybe___interceptionRedirectChain) {
        aReader->FatalError("Error deserializing 'interceptionRedirectChain' (RedirectHistoryEntryInfo[]) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _interceptionRedirectChain = *maybe___interceptionRedirectChain;
    // Sentinel = 'interceptionRedirectChain'
    if ((!((aReader)->ReadSentinel(2251754026)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'interceptionRedirectChain' (RedirectHistoryEntryInfo[]) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___interceptionFromThirdParty = IPC::ReadParam<bool>(aReader);
    if (!maybe___interceptionFromThirdParty) {
        aReader->FatalError("Error deserializing 'interceptionFromThirdParty' (bool) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _interceptionFromThirdParty = *maybe___interceptionFromThirdParty;
    // Sentinel = 'interceptionFromThirdParty'
    if ((!((aReader)->ReadSentinel(2433813172)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'interceptionFromThirdParty' (bool) member of 'IPCInternalRequest'");
        return {};
    }
    auto maybe___embedderPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginEmbedderPolicy>(aReader);
    if (!maybe___embedderPolicy) {
        aReader->FatalError("Error deserializing 'embedderPolicy' (CrossOriginEmbedderPolicy) member of 'IPCInternalRequest'");
        return {};

    }
    auto& _embedderPolicy = *maybe___embedderPolicy;
    // Sentinel = 'embedderPolicy'
    if ((!((aReader)->ReadSentinel(703792553)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'embedderPolicy' (CrossOriginEmbedderPolicy) member of 'IPCInternalRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_method),
            std::move(_urlList),
            std::move(_headersGuard),
            std::move(_headers),
            std::move(_body),
            ::int64_t{0},
            std::move(_preferredAlternativeDataType),
            std::move(_contentPolicyType),
            ::int32_t{0},
            std::move(_referrer),
            std::move(_referrerPolicy),
            std::move(_environmentReferrerPolicy),
            std::move(_requestMode),
            std::move(_requestCredentials),
            std::move(_cacheMode),
            std::move(_requestRedirect),
            std::move(_requestPriority),
            std::move(_integrity),
            std::move(_keepalive),
            std::move(_fragment),
            std::move(_principalInfo),
            std::move(_interceptionTriggeringPrincipalInfo),
            std::move(_interceptionContentPolicyType),
            std::move(_interceptionRedirectChain),
            std::move(_interceptionFromThirdParty),
            std::move(_embedderPolicy)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodySize'
    if ((!((aReader)->ReadSentinel(246809418)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->internalPriority())), 4)))) {
        aReader->FatalError("Error bulk reading fields from int32_t");
        return {};
    }
    // Sentinel = 'internalPriority'
    if ((!((aReader)->ReadSentinel(953550528)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::InternalResponseMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).type());
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
    IPC::WriteParam(aWriter, (aVar).urlList());
    // Sentinel = 'urlList'
    (aWriter)->WriteSentinel(197591792);
    IPC::WriteParam(aWriter, (aVar).statusText());
    // Sentinel = 'statusText'
    (aWriter)->WriteSentinel(397411402);
    IPC::WriteParam(aWriter, (aVar).headersGuard());
    // Sentinel = 'headersGuard'
    (aWriter)->WriteSentinel(522912976);
    IPC::WriteParam(aWriter, (aVar).headers());
    // Sentinel = 'headers'
    (aWriter)->WriteSentinel(188220125);
    IPC::WriteParam(aWriter, (aVar).errorCode());
    // Sentinel = 'errorCode'
    (aWriter)->WriteSentinel(312345510);
    IPC::WriteParam(aWriter, (aVar).alternativeDataType());
    // Sentinel = 'alternativeDataType'
    (aWriter)->WriteSentinel(1308690364);
    IPC::WriteParam(aWriter, (aVar).securityInfo());
    // Sentinel = 'securityInfo'
    (aWriter)->WriteSentinel(552535301);
    IPC::WriteParam(aWriter, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aWriter)->WriteSentinel(633472335);
    IPC::WriteParam(aWriter, (aVar).bodyBlobURISpec());
    // Sentinel = 'bodyBlobURISpec'
    (aWriter)->WriteSentinel(773391785);
    IPC::WriteParam(aWriter, (aVar).bodyLocalPath());
    // Sentinel = 'bodyLocalPath'
    (aWriter)->WriteSentinel(607061287);
    IPC::WriteParam(aWriter, (aVar).credentialsMode());
    // Sentinel = 'credentialsMode'
    (aWriter)->WriteSentinel(822347284);
    (aWriter)->WriteBytes((&((aVar).status())), 2);
    // Sentinel = 'status'
    (aWriter)->WriteSentinel(154731173);
}

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

    }
    auto& _type = *maybe___type;
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (ResponseType) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___urlList = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
    if (!maybe___urlList) {
        aReader->FatalError("Error deserializing 'urlList' (nsCString[]) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _urlList = *maybe___urlList;
    // Sentinel = 'urlList'
    if ((!((aReader)->ReadSentinel(197591792)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlList' (nsCString[]) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___statusText = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___statusText) {
        aReader->FatalError("Error deserializing 'statusText' (nsCString) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _statusText = *maybe___statusText;
    // Sentinel = 'statusText'
    if ((!((aReader)->ReadSentinel(397411402)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'statusText' (nsCString) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
    if (!maybe___headersGuard) {
        aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _headersGuard = *maybe___headersGuard;
    // Sentinel = 'headersGuard'
    if ((!((aReader)->ReadSentinel(522912976)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::HeadersEntry>>(aReader);
    if (!maybe___headers) {
        aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _headers = *maybe___headers;
    // Sentinel = 'headers'
    if ((!((aReader)->ReadSentinel(188220125)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___errorCode = IPC::ReadParam<::nsresult>(aReader);
    if (!maybe___errorCode) {
        aReader->FatalError("Error deserializing 'errorCode' (nsresult) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _errorCode = *maybe___errorCode;
    // Sentinel = 'errorCode'
    if ((!((aReader)->ReadSentinel(312345510)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'errorCode' (nsresult) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___alternativeDataType = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___alternativeDataType) {
        aReader->FatalError("Error deserializing 'alternativeDataType' (nsCString) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _alternativeDataType = *maybe___alternativeDataType;
    // Sentinel = 'alternativeDataType'
    if ((!((aReader)->ReadSentinel(1308690364)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alternativeDataType' (nsCString) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
    if (!maybe___securityInfo) {
        aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _securityInfo = *maybe___securityInfo;
    // Sentinel = 'securityInfo'
    if ((!((aReader)->ReadSentinel(552535301)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
    if (!maybe___principalInfo) {
        aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _principalInfo = *maybe___principalInfo;
    // Sentinel = 'principalInfo'
    if ((!((aReader)->ReadSentinel(633472335)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___bodyBlobURISpec = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___bodyBlobURISpec) {
        aReader->FatalError("Error deserializing 'bodyBlobURISpec' (nsCString) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _bodyBlobURISpec = *maybe___bodyBlobURISpec;
    // Sentinel = 'bodyBlobURISpec'
    if ((!((aReader)->ReadSentinel(773391785)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bodyBlobURISpec' (nsCString) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___bodyLocalPath = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___bodyLocalPath) {
        aReader->FatalError("Error deserializing 'bodyLocalPath' (nsString) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _bodyLocalPath = *maybe___bodyLocalPath;
    // Sentinel = 'bodyLocalPath'
    if ((!((aReader)->ReadSentinel(607061287)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bodyLocalPath' (nsString) member of 'InternalResponseMetadata'");
        return {};
    }
    auto maybe___credentialsMode = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
    if (!maybe___credentialsMode) {
        aReader->FatalError("Error deserializing 'credentialsMode' (RequestCredentials) member of 'InternalResponseMetadata'");
        return {};

    }
    auto& _credentialsMode = *maybe___credentialsMode;
    // Sentinel = 'credentialsMode'
    if ((!((aReader)->ReadSentinel(822347284)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'credentialsMode' (RequestCredentials) member of 'InternalResponseMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_type),
            std::move(_urlList),
            ::uint16_t{0},
            std::move(_statusText),
            std::move(_headersGuard),
            std::move(_headers),
            std::move(_errorCode),
            std::move(_alternativeDataType),
            std::move(_securityInfo),
            std::move(_principalInfo),
            std::move(_bodyBlobURISpec),
            std::move(_bodyLocalPath),
            std::move(_credentialsMode)};
    if ((!((aReader)->ReadBytesInto((&((result__)->status())), 2)))) {
        aReader->FatalError("Error bulk reading fields from uint16_t");
        return {};
    }
    // Sentinel = 'status'
    if ((!((aReader)->ReadSentinel(154731173)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentInternalResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).metadata());
    // Sentinel = 'metadata'
    (aWriter)->WriteSentinel(248251202);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).alternativeBody());
    // Sentinel = 'alternativeBody'
    (aWriter)->WriteSentinel(833816110);
    (aWriter)->WriteBytes((&((aVar).bodySize())), 8);
    // Sentinel = 'bodySize'
    (aWriter)->WriteSentinel(246809418);
}

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

    }
    auto& _metadata = *maybe___metadata;
    // Sentinel = 'metadata'
    if ((!((aReader)->ReadSentinel(248251202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToParentInternalResponse'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentStream>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
        return {};
    }
    auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentStream>>(aReader);
    if (!maybe___alternativeBody) {
        aReader->FatalError("Error deserializing 'alternativeBody' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
        return {};

    }
    auto& _alternativeBody = *maybe___alternativeBody;
    // Sentinel = 'alternativeBody'
    if ((!((aReader)->ReadSentinel(833816110)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ParentToParentStream?) member of 'ParentToParentInternalResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_metadata),
            std::move(_body),
            ::int64_t{0},
            std::move(_alternativeBody)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodySize'
    if ((!((aReader)->ReadSentinel(246809418)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToChildInternalResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).metadata());
    // Sentinel = 'metadata'
    (aWriter)->WriteSentinel(248251202);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).alternativeBody());
    // Sentinel = 'alternativeBody'
    (aWriter)->WriteSentinel(833816110);
    (aWriter)->WriteBytes((&((aVar).bodySize())), 8);
    // Sentinel = 'bodySize'
    (aWriter)->WriteSentinel(246809418);
}

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

    }
    auto& _metadata = *maybe___metadata;
    // Sentinel = 'metadata'
    if ((!((aReader)->ReadSentinel(248251202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ParentToChildInternalResponse'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildStream>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
        return {};
    }
    auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildStream>>(aReader);
    if (!maybe___alternativeBody) {
        aReader->FatalError("Error deserializing 'alternativeBody' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
        return {};

    }
    auto& _alternativeBody = *maybe___alternativeBody;
    // Sentinel = 'alternativeBody'
    if ((!((aReader)->ReadSentinel(833816110)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ParentToChildStream?) member of 'ParentToChildInternalResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_metadata),
            std::move(_body),
            ::int64_t{0},
            std::move(_alternativeBody)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodySize'
    if ((!((aReader)->ReadSentinel(246809418)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ChildToParentInternalResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).metadata());
    // Sentinel = 'metadata'
    (aWriter)->WriteSentinel(248251202);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).alternativeBody());
    // Sentinel = 'alternativeBody'
    (aWriter)->WriteSentinel(833816110);
    (aWriter)->WriteBytes((&((aVar).bodySize())), 8);
    // Sentinel = 'bodySize'
    (aWriter)->WriteSentinel(246809418);
}

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

    }
    auto& _metadata = *maybe___metadata;
    // Sentinel = 'metadata'
    if ((!((aReader)->ReadSentinel(248251202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (InternalResponseMetadata) member of 'ChildToParentInternalResponse'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ChildToParentStream>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
        return {};
    }
    auto maybe___alternativeBody = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ChildToParentStream>>(aReader);
    if (!maybe___alternativeBody) {
        aReader->FatalError("Error deserializing 'alternativeBody' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
        return {};

    }
    auto& _alternativeBody = *maybe___alternativeBody;
    // Sentinel = 'alternativeBody'
    if ((!((aReader)->ReadSentinel(833816110)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alternativeBody' (ChildToParentStream?) member of 'ChildToParentInternalResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_metadata),
            std::move(_body),
            ::int64_t{0},
            std::move(_alternativeBody)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodySize())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodySize'
    if ((!((aReader)->ReadSentinel(246809418)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ResponseTiming>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).timingData());
    // Sentinel = 'timingData'
    (aWriter)->WriteSentinel(379388931);
    IPC::WriteParam(aWriter, (aVar).initiatorType());
    // Sentinel = 'initiatorType'
    (aWriter)->WriteSentinel(642647414);
    IPC::WriteParam(aWriter, (aVar).entryName());
    // Sentinel = 'entryName'
    (aWriter)->WriteSentinel(315950004);
}

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

    }
    auto& _timingData = *maybe___timingData;
    // Sentinel = 'timingData'
    if ((!((aReader)->ReadSentinel(379388931)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timingData' (IPCPerformanceTimingData) member of 'ResponseTiming'");
        return {};
    }
    auto maybe___initiatorType = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___initiatorType) {
        aReader->FatalError("Error deserializing 'initiatorType' (nsString) member of 'ResponseTiming'");
        return {};

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

    }
    auto& _entryName = *maybe___entryName;
    // Sentinel = 'entryName'
    if ((!((aReader)->ReadSentinel(315950004)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryName' (nsString) member of 'ResponseTiming'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_timingData),
            std::move(_initiatorType),
            std::move(_entryName)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::ResponseEndArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___endReason = IPC::ReadParam<::mozilla::dom::FetchDriverObserver::EndReason>(aReader);
    if (!maybe___endReason) {
        aReader->FatalError("Error deserializing 'endReason' (EndReason) member of 'ResponseEndArgs'");
        return {};

    }
    auto& _endReason = *maybe___endReason;
    // Sentinel = 'endReason'
    if ((!((aReader)->ReadSentinel(298845088)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endReason' (EndReason) member of 'ResponseEndArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_endReason)};
    return result__;
}

} // namespace IPC
