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


#include "mozilla/dom/ServiceWorkerIPCUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "ipc/ErrorIPCUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.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/ServiceWorkerOpArgs.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 ServiceWorkerCheckScriptEvaluationOpArgs|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

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

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

} // namespace IPC

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

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

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

    }
    auto& _state = *maybe___state;
    // Sentinel = 'state'
    if ((!((aReader)->ReadSentinel(109314594)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'state' (ServiceWorkerState) member of 'ServiceWorkerUpdateStateOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_state)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerTerminateWorkerOpArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    (aWriter)->WriteBytes((&((aVar).shutdownStateId())), 4);
    // Sentinel = 'shutdownStateId'
    (aWriter)->WriteSentinel(854918699);
}

auto ParamTraits<::mozilla::dom::ServiceWorkerTerminateWorkerOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->shutdownStateId())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'shutdownStateId'
    if ((!((aReader)->ReadSentinel(854918699)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _eventName = *maybe___eventName;
    // Sentinel = 'eventName'
    if ((!((aReader)->ReadSentinel(310051748)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'eventName' (nsString) member of 'ServiceWorkerLifeCycleEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_eventName)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _cookie = *maybe___cookie;
    // Sentinel = 'cookie'
    if ((!((aReader)->ReadSentinel(146211451)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cookie' (CookieStruct) member of 'ServiceWorkerCookieChangeEventOpArgs'");
        return {};
    }
    auto maybe___deleted = IPC::ReadParam<bool>(aReader);
    if (!maybe___deleted) {
        aReader->FatalError("Error deserializing 'deleted' (bool) member of 'ServiceWorkerCookieChangeEventOpArgs'");
        return {};

    }
    auto& _deleted = *maybe___deleted;
    // Sentinel = 'deleted'
    if ((!((aReader)->ReadSentinel(190513880)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'deleted' (bool) member of 'ServiceWorkerCookieChangeEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cookie),
            std::move(_deleted)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OptionalPushData|
//
namespace mozilla {
namespace dom {
auto OptionalPushData::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tvoid_t:
        {
            (ptr_void_t())->~void_t__tdef();
            break;
        }
    case TArrayOfuint8_t:
        {
            (ptr_ArrayOfuint8_t())->~ArrayOfuint8_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(const void_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(void_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(const nsTArray<uint8_t>& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>((aOther).Clone());
    mType = TArrayOfuint8_t;
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(nsTArray<uint8_t>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move(aOther));
    mType = TArrayOfuint8_t;
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(const OptionalPushData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case TArrayOfuint8_t:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(((aOther).get_ArrayOfuint8_t()).Clone());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OptionalPushData::OptionalPushData(OptionalPushData&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case TArrayOfuint8_t:
        {
            new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move((aOther).get_ArrayOfuint8_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OptionalPushData::operator=(const void_t& aRhs) -> OptionalPushData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(aRhs);
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalPushData::operator=(void_t&& aRhs) -> OptionalPushData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aRhs));
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalPushData::operator=(const nsTArray<uint8_t>& aRhs) -> OptionalPushData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>((aRhs).Clone());
    mType = TArrayOfuint8_t;
    return (*(this));
}

auto OptionalPushData::operator=(nsTArray<uint8_t>&& aRhs) -> OptionalPushData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move(aRhs));
    mType = TArrayOfuint8_t;
    return (*(this));
}

auto OptionalPushData::operator=(const OptionalPushData& aRhs) -> OptionalPushData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tvoid_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aRhs).get_void_t());
            break;
        }
    case TArrayOfuint8_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(((aRhs).get_ArrayOfuint8_t()).Clone());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OptionalPushData::operator=(OptionalPushData&& aRhs) -> OptionalPushData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tvoid_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aRhs).get_void_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TArrayOfuint8_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ArrayOfuint8_t()) nsTArray<uint8_t>(std::move((aRhs).get_ArrayOfuint8_t()));
            (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::OptionalPushData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::OptionalPushData union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'OptionalPushData'
    (aWriter)->WriteSentinel(917112417);

    switch (type) {
    case union__::Tvoid_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_void_t());
            // Sentinel = 'Tvoid_t'
            (aWriter)->WriteSentinel(189006554);
            return;
        }
    case union__::TArrayOfuint8_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_ArrayOfuint8_t());
            // Sentinel = 'TArrayOfuint8_t'
            (aWriter)->WriteSentinel(771753428);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union OptionalPushData");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _messageId = *maybe___messageId;
    // Sentinel = 'messageId'
    if ((!((aReader)->ReadSentinel(310576019)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'messageId' (nsString) member of 'ServiceWorkerPushEventOpArgs'");
        return {};
    }
    auto maybe___data = IPC::ReadParam<::mozilla::dom::OptionalPushData>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (OptionalPushData) member of 'ServiceWorkerPushEventOpArgs'");
        return {};

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::PushSubscriptionData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).endpoint());
    // Sentinel = 'endpoint'
    (aWriter)->WriteSentinel(251724642);
    IPC::WriteParam(aWriter, (aVar).rawP256dhKey());
    // Sentinel = 'rawP256dhKey'
    (aWriter)->WriteSentinel(453248045);
    IPC::WriteParam(aWriter, (aVar).authSecret());
    // Sentinel = 'authSecret'
    (aWriter)->WriteSentinel(376701977);
    IPC::WriteParam(aWriter, (aVar).appServerKey());
    // Sentinel = 'appServerKey'
    (aWriter)->WriteSentinel(530711778);
}

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

    }
    auto& _endpoint = *maybe___endpoint;
    // Sentinel = 'endpoint'
    if ((!((aReader)->ReadSentinel(251724642)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endpoint' (nsString) member of 'PushSubscriptionData'");
        return {};
    }
    auto maybe___rawP256dhKey = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___rawP256dhKey) {
        aReader->FatalError("Error deserializing 'rawP256dhKey' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};

    }
    auto& _rawP256dhKey = *maybe___rawP256dhKey;
    // Sentinel = 'rawP256dhKey'
    if ((!((aReader)->ReadSentinel(453248045)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rawP256dhKey' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};
    }
    auto maybe___authSecret = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___authSecret) {
        aReader->FatalError("Error deserializing 'authSecret' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};

    }
    auto& _authSecret = *maybe___authSecret;
    // Sentinel = 'authSecret'
    if ((!((aReader)->ReadSentinel(376701977)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'authSecret' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};
    }
    auto maybe___appServerKey = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___appServerKey) {
        aReader->FatalError("Error deserializing 'appServerKey' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};

    }
    auto& _appServerKey = *maybe___appServerKey;
    // Sentinel = 'appServerKey'
    if ((!((aReader)->ReadSentinel(530711778)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'appServerKey' (uint8_t[]) member of 'PushSubscriptionData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_endpoint),
            std::move(_rawP256dhKey),
            std::move(_authSecret),
            std::move(_appServerKey)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _oldSubscription = *maybe___oldSubscription;
    // Sentinel = 'oldSubscription'
    if ((!((aReader)->ReadSentinel(831063621)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'oldSubscription' (PushSubscriptionData?) member of 'ServiceWorkerPushSubscriptionChangeEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_oldSubscription)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _notification = *maybe___notification;
    // Sentinel = 'notification'
    if ((!((aReader)->ReadSentinel(550438152)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'notification' (IPCNotification) member of 'ServiceWorkerNotificationClickEventOpArgs'");
        return {};
    }
    auto maybe___action = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___action) {
        aReader->FatalError("Error deserializing 'action' (nsString) member of 'ServiceWorkerNotificationClickEventOpArgs'");
        return {};

    }
    auto& _action = *maybe___action;
    // Sentinel = 'action'
    if ((!((aReader)->ReadSentinel(143786623)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'action' (nsString) member of 'ServiceWorkerNotificationClickEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_notification),
            std::move(_action)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _notification = *maybe___notification;
    // Sentinel = 'notification'
    if ((!((aReader)->ReadSentinel(550438152)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'notification' (IPCNotification) member of 'ServiceWorkerNotificationCloseEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_notification)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ServiceWorkerNotificationEventOpArgs|
//
namespace mozilla {
namespace dom {
auto ServiceWorkerNotificationEventOpArgs::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TServiceWorkerNotificationClickEventOpArgs:
        {
            (ptr_ServiceWorkerNotificationClickEventOpArgs())->~ServiceWorkerNotificationClickEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerNotificationCloseEventOpArgs:
        {
            (ptr_ServiceWorkerNotificationCloseEventOpArgs())->~ServiceWorkerNotificationCloseEventOpArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(const ServiceWorkerNotificationClickEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(aOther);
    mType = TServiceWorkerNotificationClickEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(ServiceWorkerNotificationClickEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(std::move(aOther));
    mType = TServiceWorkerNotificationClickEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(const ServiceWorkerNotificationCloseEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(aOther);
    mType = TServiceWorkerNotificationCloseEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(ServiceWorkerNotificationCloseEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(std::move(aOther));
    mType = TServiceWorkerNotificationCloseEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(const ServiceWorkerNotificationEventOpArgs& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TServiceWorkerNotificationClickEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs((aOther).get_ServiceWorkerNotificationClickEventOpArgs());
            break;
        }
    case TServiceWorkerNotificationCloseEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs((aOther).get_ServiceWorkerNotificationCloseEventOpArgs());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ServiceWorkerNotificationEventOpArgs::ServiceWorkerNotificationEventOpArgs(ServiceWorkerNotificationEventOpArgs&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TServiceWorkerNotificationClickEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(std::move((aOther).get_ServiceWorkerNotificationClickEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerNotificationCloseEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(std::move((aOther).get_ServiceWorkerNotificationCloseEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ServiceWorkerNotificationEventOpArgs::operator=(const ServiceWorkerNotificationClickEventOpArgs& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(aRhs);
    mType = TServiceWorkerNotificationClickEventOpArgs;
    return (*(this));
}

auto ServiceWorkerNotificationEventOpArgs::operator=(ServiceWorkerNotificationClickEventOpArgs&& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerNotificationClickEventOpArgs;
    return (*(this));
}

auto ServiceWorkerNotificationEventOpArgs::operator=(const ServiceWorkerNotificationCloseEventOpArgs& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(aRhs);
    mType = TServiceWorkerNotificationCloseEventOpArgs;
    return (*(this));
}

auto ServiceWorkerNotificationEventOpArgs::operator=(ServiceWorkerNotificationCloseEventOpArgs&& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerNotificationCloseEventOpArgs;
    return (*(this));
}

auto ServiceWorkerNotificationEventOpArgs::operator=(const ServiceWorkerNotificationEventOpArgs& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TServiceWorkerNotificationClickEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs((aRhs).get_ServiceWorkerNotificationClickEventOpArgs());
            break;
        }
    case TServiceWorkerNotificationCloseEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs((aRhs).get_ServiceWorkerNotificationCloseEventOpArgs());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto ServiceWorkerNotificationEventOpArgs::operator=(ServiceWorkerNotificationEventOpArgs&& aRhs) -> ServiceWorkerNotificationEventOpArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TServiceWorkerNotificationClickEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationClickEventOpArgs()) ServiceWorkerNotificationClickEventOpArgs(std::move((aRhs).get_ServiceWorkerNotificationClickEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerNotificationCloseEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationCloseEventOpArgs()) ServiceWorkerNotificationCloseEventOpArgs(std::move((aRhs).get_ServiceWorkerNotificationCloseEventOpArgs()));
            (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::ServiceWorkerNotificationEventOpArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ServiceWorkerNotificationEventOpArgs union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ServiceWorkerNotificationEventOpArgs'
    (aWriter)->WriteSentinel(217845377);

    switch (type) {
    case union__::TServiceWorkerNotificationClickEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerNotificationClickEventOpArgs());
            // Sentinel = 'TServiceWorkerNotificationClickEventOpArgs'
            (aWriter)->WriteSentinel(1745948859);
            return;
        }
    case union__::TServiceWorkerNotificationCloseEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerNotificationCloseEventOpArgs());
            // Sentinel = 'TServiceWorkerNotificationCloseEventOpArgs'
            (aWriter)->WriteSentinel(1760366795);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ServiceWorkerNotificationEventOpArgs");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _apiNamespace = *maybe___apiNamespace;
    // Sentinel = 'apiNamespace'
    if ((!((aReader)->ReadSentinel(518915272)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'apiNamespace' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
        return {};
    }
    auto maybe___apiEventName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___apiEventName) {
        aReader->FatalError("Error deserializing 'apiEventName' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
        return {};

    }
    auto& _apiEventName = *maybe___apiEventName;
    // Sentinel = 'apiEventName'
    if ((!((aReader)->ReadSentinel(517211326)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'apiEventName' (nsString) member of 'ServiceWorkerExtensionAPIEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_apiNamespace),
            std::move(_apiEventName)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _source = *maybe___source;
    // Sentinel = 'source'
    if ((!((aReader)->ReadSentinel(154665618)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'source' (PostMessageSource) member of 'ServiceWorkerMessageEventOpArgs'");
        return {};
    }
    auto maybe___clonedData = IPC::ReadParam<::mozilla::dom::ClonedOrErrorMessageData>(aReader);
    if (!maybe___clonedData) {
        aReader->FatalError("Error deserializing 'clonedData' (ClonedOrErrorMessageData) member of 'ServiceWorkerMessageEventOpArgs'");
        return {};

    }
    auto& _clonedData = *maybe___clonedData;
    // Sentinel = 'clonedData'
    if ((!((aReader)->ReadSentinel(368837616)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clonedData' (ClonedOrErrorMessageData) member of 'ServiceWorkerMessageEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_source),
            std::move(_clonedData)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ServiceWorkerFetchEventOpArgsCommon>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).workerScriptSpec());
    // Sentinel = 'workerScriptSpec'
    (aWriter)->WriteSentinel(958596763);
    IPC::WriteParam(aWriter, (aVar).internalRequest());
    // Sentinel = 'internalRequest'
    (aWriter)->WriteSentinel(839059015);
    IPC::WriteParam(aWriter, (aVar).clientId());
    // Sentinel = 'clientId'
    (aWriter)->WriteSentinel(244122413);
    IPC::WriteParam(aWriter, (aVar).resultingClientId());
    // Sentinel = 'resultingClientId'
    (aWriter)->WriteSentinel(1073022698);
    IPC::WriteParam(aWriter, (aVar).isNonSubresourceRequest());
    // Sentinel = 'isNonSubresourceRequest'
    (aWriter)->WriteSentinel(1894386051);
    IPC::WriteParam(aWriter, (aVar).preloadNavigation());
    // Sentinel = 'preloadNavigation'
    (aWriter)->WriteSentinel(1050216184);
    IPC::WriteParam(aWriter, (aVar).testingInjectCancellation());
    // Sentinel = 'testingInjectCancellation'
    (aWriter)->WriteSentinel(2219510313);
}

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

    }
    auto& _workerScriptSpec = *maybe___workerScriptSpec;
    // Sentinel = 'workerScriptSpec'
    if ((!((aReader)->ReadSentinel(958596763)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'workerScriptSpec' (nsCString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___internalRequest = IPC::ReadParam<::mozilla::dom::IPCInternalRequest>(aReader);
    if (!maybe___internalRequest) {
        aReader->FatalError("Error deserializing 'internalRequest' (IPCInternalRequest) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _internalRequest = *maybe___internalRequest;
    // Sentinel = 'internalRequest'
    if ((!((aReader)->ReadSentinel(839059015)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'internalRequest' (IPCInternalRequest) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___clientId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___clientId) {
        aReader->FatalError("Error deserializing 'clientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _clientId = *maybe___clientId;
    // Sentinel = 'clientId'
    if ((!((aReader)->ReadSentinel(244122413)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___resultingClientId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___resultingClientId) {
        aReader->FatalError("Error deserializing 'resultingClientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _resultingClientId = *maybe___resultingClientId;
    // Sentinel = 'resultingClientId'
    if ((!((aReader)->ReadSentinel(1073022698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'resultingClientId' (nsString) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___isNonSubresourceRequest = IPC::ReadParam<bool>(aReader);
    if (!maybe___isNonSubresourceRequest) {
        aReader->FatalError("Error deserializing 'isNonSubresourceRequest' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _isNonSubresourceRequest = *maybe___isNonSubresourceRequest;
    // Sentinel = 'isNonSubresourceRequest'
    if ((!((aReader)->ReadSentinel(1894386051)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isNonSubresourceRequest' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___preloadNavigation = IPC::ReadParam<bool>(aReader);
    if (!maybe___preloadNavigation) {
        aReader->FatalError("Error deserializing 'preloadNavigation' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _preloadNavigation = *maybe___preloadNavigation;
    // Sentinel = 'preloadNavigation'
    if ((!((aReader)->ReadSentinel(1050216184)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadNavigation' (bool) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    auto maybe___testingInjectCancellation = IPC::ReadParam<::nsresult>(aReader);
    if (!maybe___testingInjectCancellation) {
        aReader->FatalError("Error deserializing 'testingInjectCancellation' (nsresult) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};

    }
    auto& _testingInjectCancellation = *maybe___testingInjectCancellation;
    // Sentinel = 'testingInjectCancellation'
    if ((!((aReader)->ReadSentinel(2219510313)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'testingInjectCancellation' (nsresult) member of 'ServiceWorkerFetchEventOpArgsCommon'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_workerScriptSpec),
            std::move(_internalRequest),
            std::move(_clientId),
            std::move(_resultingClientId),
            std::move(_isNonSubresourceRequest),
            std::move(_preloadNavigation),
            std::move(_testingInjectCancellation)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentServiceWorkerFetchEventOpArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).common());
    // Sentinel = 'common'
    (aWriter)->WriteSentinel(147456650);
    IPC::WriteParam(aWriter, (aVar).preloadResponse());
    // Sentinel = 'preloadResponse'
    (aWriter)->WriteSentinel(832898615);
    IPC::WriteParam(aWriter, (aVar).preloadResponseTiming());
    // Sentinel = 'preloadResponseTiming'
    (aWriter)->WriteSentinel(1596328095);
    IPC::WriteParam(aWriter, (aVar).preloadResponseEndArgs());
    // Sentinel = 'preloadResponseEndArgs'
    (aWriter)->WriteSentinel(1730939099);
}

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

    }
    auto& _common = *maybe___common;
    // Sentinel = 'common'
    if ((!((aReader)->ReadSentinel(147456650)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToParentInternalResponse>>(aReader);
    if (!maybe___preloadResponse) {
        aReader->FatalError("Error deserializing 'preloadResponse' (ParentToParentInternalResponse?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponse = *maybe___preloadResponse;
    // Sentinel = 'preloadResponse'
    if ((!((aReader)->ReadSentinel(832898615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponse' (ParentToParentInternalResponse?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponseTiming = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseTiming>>(aReader);
    if (!maybe___preloadResponseTiming) {
        aReader->FatalError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponseTiming = *maybe___preloadResponseTiming;
    // Sentinel = 'preloadResponseTiming'
    if ((!((aReader)->ReadSentinel(1596328095)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponseEndArgs = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseEndArgs>>(aReader);
    if (!maybe___preloadResponseEndArgs) {
        aReader->FatalError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponseEndArgs = *maybe___preloadResponseEndArgs;
    // Sentinel = 'preloadResponseEndArgs'
    if ((!((aReader)->ReadSentinel(1730939099)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToParentServiceWorkerFetchEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_common),
            std::move(_preloadResponse),
            std::move(_preloadResponseTiming),
            std::move(_preloadResponseEndArgs)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToChildServiceWorkerFetchEventOpArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).common());
    // Sentinel = 'common'
    (aWriter)->WriteSentinel(147456650);
    IPC::WriteParam(aWriter, (aVar).preloadResponse());
    // Sentinel = 'preloadResponse'
    (aWriter)->WriteSentinel(832898615);
    IPC::WriteParam(aWriter, (aVar).preloadResponseTiming());
    // Sentinel = 'preloadResponseTiming'
    (aWriter)->WriteSentinel(1596328095);
    IPC::WriteParam(aWriter, (aVar).preloadResponseEndArgs());
    // Sentinel = 'preloadResponseEndArgs'
    (aWriter)->WriteSentinel(1730939099);
}

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

    }
    auto& _common = *maybe___common;
    // Sentinel = 'common'
    if ((!((aReader)->ReadSentinel(147456650)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'common' (ServiceWorkerFetchEventOpArgsCommon) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ParentToChildInternalResponse>>(aReader);
    if (!maybe___preloadResponse) {
        aReader->FatalError("Error deserializing 'preloadResponse' (ParentToChildInternalResponse?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponse = *maybe___preloadResponse;
    // Sentinel = 'preloadResponse'
    if ((!((aReader)->ReadSentinel(832898615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponse' (ParentToChildInternalResponse?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponseTiming = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseTiming>>(aReader);
    if (!maybe___preloadResponseTiming) {
        aReader->FatalError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponseTiming = *maybe___preloadResponseTiming;
    // Sentinel = 'preloadResponseTiming'
    if ((!((aReader)->ReadSentinel(1596328095)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseTiming' (ResponseTiming?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};
    }
    auto maybe___preloadResponseEndArgs = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::ResponseEndArgs>>(aReader);
    if (!maybe___preloadResponseEndArgs) {
        aReader->FatalError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};

    }
    auto& _preloadResponseEndArgs = *maybe___preloadResponseEndArgs;
    // Sentinel = 'preloadResponseEndArgs'
    if ((!((aReader)->ReadSentinel(1730939099)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preloadResponseEndArgs' (ResponseEndArgs?) member of 'ParentToChildServiceWorkerFetchEventOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_common),
            std::move(_preloadResponse),
            std::move(_preloadResponseTiming),
            std::move(_preloadResponseEndArgs)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _onContentBlockingAllowList = *maybe___onContentBlockingAllowList;
    // Sentinel = 'onContentBlockingAllowList'
    if ((!((aReader)->ReadSentinel(2365852285)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'onContentBlockingAllowList' (bool) member of 'ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_onContentBlockingAllowList)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ServiceWorkerOpArgs|
//
namespace mozilla {
namespace dom {
auto ServiceWorkerOpArgs::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TServiceWorkerCheckScriptEvaluationOpArgs:
        {
            (ptr_ServiceWorkerCheckScriptEvaluationOpArgs())->~ServiceWorkerCheckScriptEvaluationOpArgs__tdef();
            break;
        }
    case TServiceWorkerUpdateStateOpArgs:
        {
            (ptr_ServiceWorkerUpdateStateOpArgs())->~ServiceWorkerUpdateStateOpArgs__tdef();
            break;
        }
    case TServiceWorkerTerminateWorkerOpArgs:
        {
            (ptr_ServiceWorkerTerminateWorkerOpArgs())->~ServiceWorkerTerminateWorkerOpArgs__tdef();
            break;
        }
    case TServiceWorkerLifeCycleEventOpArgs:
        {
            (ptr_ServiceWorkerLifeCycleEventOpArgs())->~ServiceWorkerLifeCycleEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerCookieChangeEventOpArgs:
        {
            (ptr_ServiceWorkerCookieChangeEventOpArgs())->~ServiceWorkerCookieChangeEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerPushEventOpArgs:
        {
            (ptr_ServiceWorkerPushEventOpArgs())->~ServiceWorkerPushEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerPushSubscriptionChangeEventOpArgs:
        {
            (ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs())->~ServiceWorkerPushSubscriptionChangeEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerNotificationEventOpArgs:
        {
            (ptr_ServiceWorkerNotificationEventOpArgs())->~ServiceWorkerNotificationEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerMessageEventOpArgs:
        {
            (ptr_ServiceWorkerMessageEventOpArgs())->~ServiceWorkerMessageEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpArgs:
        {
            (ptr_ServiceWorkerExtensionAPIEventOpArgs())->~ServiceWorkerExtensionAPIEventOpArgs__tdef();
            break;
        }
    case TParentToChildServiceWorkerFetchEventOpArgs:
        {
            (ptr_ParentToChildServiceWorkerFetchEventOpArgs())->~ParentToChildServiceWorkerFetchEventOpArgs__tdef();
            break;
        }
    case TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs:
        {
            (ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs())->~ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerCheckScriptEvaluationOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(aOther);
    mType = TServiceWorkerCheckScriptEvaluationOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerCheckScriptEvaluationOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move(aOther));
    mType = TServiceWorkerCheckScriptEvaluationOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerUpdateStateOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(aOther);
    mType = TServiceWorkerUpdateStateOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerUpdateStateOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move(aOther));
    mType = TServiceWorkerUpdateStateOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerTerminateWorkerOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(aOther);
    mType = TServiceWorkerTerminateWorkerOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerTerminateWorkerOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move(aOther));
    mType = TServiceWorkerTerminateWorkerOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerLifeCycleEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(aOther);
    mType = TServiceWorkerLifeCycleEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerLifeCycleEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move(aOther));
    mType = TServiceWorkerLifeCycleEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerCookieChangeEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(aOther);
    mType = TServiceWorkerCookieChangeEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerCookieChangeEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(std::move(aOther));
    mType = TServiceWorkerCookieChangeEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerPushEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(aOther);
    mType = TServiceWorkerPushEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerPushEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move(aOther));
    mType = TServiceWorkerPushEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerPushSubscriptionChangeEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(aOther);
    mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerPushSubscriptionChangeEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move(aOther));
    mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerNotificationEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(aOther);
    mType = TServiceWorkerNotificationEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerNotificationEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move(aOther));
    mType = TServiceWorkerNotificationEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerMessageEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move(aOther));
    mType = TServiceWorkerMessageEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerExtensionAPIEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(aOther);
    mType = TServiceWorkerExtensionAPIEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerExtensionAPIEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move(aOther));
    mType = TServiceWorkerExtensionAPIEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ParentToChildServiceWorkerFetchEventOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(aOther);
    mType = TParentToChildServiceWorkerFetchEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ParentToChildServiceWorkerFetchEventOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move(aOther));
    mType = TParentToChildServiceWorkerFetchEventOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(const ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(aOther);
    mType = TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(std::move(aOther));
    mType = TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs;
}

MOZ_IMPLICIT ServiceWorkerOpArgs::ServiceWorkerOpArgs(ServiceWorkerOpArgs&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TServiceWorkerCheckScriptEvaluationOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move((aOther).get_ServiceWorkerCheckScriptEvaluationOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerUpdateStateOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move((aOther).get_ServiceWorkerUpdateStateOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerTerminateWorkerOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move((aOther).get_ServiceWorkerTerminateWorkerOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerLifeCycleEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move((aOther).get_ServiceWorkerLifeCycleEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerCookieChangeEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(std::move((aOther).get_ServiceWorkerCookieChangeEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerPushEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move((aOther).get_ServiceWorkerPushEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerPushSubscriptionChangeEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move((aOther).get_ServiceWorkerPushSubscriptionChangeEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerNotificationEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move((aOther).get_ServiceWorkerNotificationEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerMessageEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move((aOther).get_ServiceWorkerMessageEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move((aOther).get_ServiceWorkerExtensionAPIEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TParentToChildServiceWorkerFetchEventOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move((aOther).get_ParentToChildServiceWorkerFetchEventOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(std::move((aOther).get_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerCheckScriptEvaluationOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(aRhs);
    mType = TServiceWorkerCheckScriptEvaluationOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerCheckScriptEvaluationOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move(aRhs));
    mType = TServiceWorkerCheckScriptEvaluationOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerUpdateStateOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(aRhs);
    mType = TServiceWorkerUpdateStateOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerUpdateStateOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move(aRhs));
    mType = TServiceWorkerUpdateStateOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerTerminateWorkerOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(aRhs);
    mType = TServiceWorkerTerminateWorkerOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerTerminateWorkerOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move(aRhs));
    mType = TServiceWorkerTerminateWorkerOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerLifeCycleEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(aRhs);
    mType = TServiceWorkerLifeCycleEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerLifeCycleEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerLifeCycleEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerCookieChangeEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(aRhs);
    mType = TServiceWorkerCookieChangeEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerCookieChangeEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerCookieChangeEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerPushEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(aRhs);
    mType = TServiceWorkerPushEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerPushEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerPushEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerPushSubscriptionChangeEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(aRhs);
    mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerPushSubscriptionChangeEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerPushSubscriptionChangeEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerNotificationEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(aRhs);
    mType = TServiceWorkerNotificationEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerNotificationEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerNotificationEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerMessageEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerMessageEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerExtensionAPIEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(aRhs);
    mType = TServiceWorkerExtensionAPIEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerExtensionAPIEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move(aRhs));
    mType = TServiceWorkerExtensionAPIEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ParentToChildServiceWorkerFetchEventOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(aRhs);
    mType = TParentToChildServiceWorkerFetchEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ParentToChildServiceWorkerFetchEventOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move(aRhs));
    mType = TParentToChildServiceWorkerFetchEventOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(const ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(aRhs);
    mType = TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(std::move(aRhs));
    mType = TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs;
    return (*(this));
}

auto ServiceWorkerOpArgs::operator=(ServiceWorkerOpArgs&& aRhs) -> ServiceWorkerOpArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TServiceWorkerCheckScriptEvaluationOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpArgs()) ServiceWorkerCheckScriptEvaluationOpArgs(std::move((aRhs).get_ServiceWorkerCheckScriptEvaluationOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerUpdateStateOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateStateOpArgs()) ServiceWorkerUpdateStateOpArgs(std::move((aRhs).get_ServiceWorkerUpdateStateOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerTerminateWorkerOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerTerminateWorkerOpArgs()) ServiceWorkerTerminateWorkerOpArgs(std::move((aRhs).get_ServiceWorkerTerminateWorkerOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerLifeCycleEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerLifeCycleEventOpArgs()) ServiceWorkerLifeCycleEventOpArgs(std::move((aRhs).get_ServiceWorkerLifeCycleEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerCookieChangeEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCookieChangeEventOpArgs()) ServiceWorkerCookieChangeEventOpArgs(std::move((aRhs).get_ServiceWorkerCookieChangeEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerPushEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerPushEventOpArgs()) ServiceWorkerPushEventOpArgs(std::move((aRhs).get_ServiceWorkerPushEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerPushSubscriptionChangeEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerPushSubscriptionChangeEventOpArgs()) ServiceWorkerPushSubscriptionChangeEventOpArgs(std::move((aRhs).get_ServiceWorkerPushSubscriptionChangeEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerNotificationEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerNotificationEventOpArgs()) ServiceWorkerNotificationEventOpArgs(std::move((aRhs).get_ServiceWorkerNotificationEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerMessageEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerMessageEventOpArgs()) ServiceWorkerMessageEventOpArgs(std::move((aRhs).get_ServiceWorkerMessageEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpArgs()) ServiceWorkerExtensionAPIEventOpArgs(std::move((aRhs).get_ServiceWorkerExtensionAPIEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TParentToChildServiceWorkerFetchEventOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToChildServiceWorkerFetchEventOpArgs()) ParentToChildServiceWorkerFetchEventOpArgs(std::move((aRhs).get_ParentToChildServiceWorkerFetchEventOpArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()) ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs(std::move((aRhs).get_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs()));
            (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::ServiceWorkerOpArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ServiceWorkerOpArgs union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ServiceWorkerOpArgs'
    (aWriter)->WriteSentinel(1274349464);

    switch (type) {
    case union__::TServiceWorkerCheckScriptEvaluationOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerCheckScriptEvaluationOpArgs());
            // Sentinel = 'TServiceWorkerCheckScriptEvaluationOpArgs'
            (aWriter)->WriteSentinel(1425936471);
            return;
        }
    case union__::TServiceWorkerUpdateStateOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerUpdateStateOpArgs());
            // Sentinel = 'TServiceWorkerUpdateStateOpArgs'
            (aWriter)->WriteSentinel(3300527184);
            return;
        }
    case union__::TServiceWorkerTerminateWorkerOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerTerminateWorkerOpArgs());
            // Sentinel = 'TServiceWorkerTerminateWorkerOpArgs'
            (aWriter)->WriteSentinel(4230286863);
            return;
        }
    case union__::TServiceWorkerLifeCycleEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerLifeCycleEventOpArgs());
            // Sentinel = 'TServiceWorkerLifeCycleEventOpArgs'
            (aWriter)->WriteSentinel(3917942110);
            return;
        }
    case union__::TServiceWorkerCookieChangeEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerCookieChangeEventOpArgs());
            // Sentinel = 'TServiceWorkerCookieChangeEventOpArgs'
            (aWriter)->WriteSentinel(343477902);
            return;
        }
    case union__::TServiceWorkerPushEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerPushEventOpArgs());
            // Sentinel = 'TServiceWorkerPushEventOpArgs'
            (aWriter)->WriteSentinel(2897152910);
            return;
        }
    case union__::TServiceWorkerPushSubscriptionChangeEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerPushSubscriptionChangeEventOpArgs());
            // Sentinel = 'TServiceWorkerPushSubscriptionChangeEventOpArgs'
            (aWriter)->WriteSentinel(3308065497);
            return;
        }
    case union__::TServiceWorkerNotificationEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerNotificationEventOpArgs());
            // Sentinel = 'TServiceWorkerNotificationEventOpArgs'
            (aWriter)->WriteSentinel(421596885);
            return;
        }
    case union__::TServiceWorkerMessageEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerMessageEventOpArgs());
            // Sentinel = 'TServiceWorkerMessageEventOpArgs'
            (aWriter)->WriteSentinel(3507686579);
            return;
        }
    case union__::TServiceWorkerExtensionAPIEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerExtensionAPIEventOpArgs());
            // Sentinel = 'TServiceWorkerExtensionAPIEventOpArgs'
            (aWriter)->WriteSentinel(360779397);
            return;
        }
    case union__::TParentToChildServiceWorkerFetchEventOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ParentToChildServiceWorkerFetchEventOpArgs());
            // Sentinel = 'TParentToChildServiceWorkerFetchEventOpArgs'
            (aWriter)->WriteSentinel(1905725673);
            return;
        }
    case union__::TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs());
            // Sentinel = 'TServiceWorkerUpdateIsOnContentBlockingAllowListOpArgs'
            (aWriter)->WriteSentinel(1267668327);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ServiceWorkerOpArgs");
            return;
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace IPC

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

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::FetchEventRespondWithClosure>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).respondWithScriptSpec());
    // Sentinel = 'respondWithScriptSpec'
    (aWriter)->WriteSentinel(1605044376);
    (aWriter)->WriteBytes((&((aVar).respondWithLineNumber())), 8);
    // Sentinel = 'respondWithLineNumber | respondWithColumnNumber'
    (aWriter)->WriteSentinel(3238269619);
}

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

    }
    auto& _respondWithScriptSpec = *maybe___respondWithScriptSpec;
    // Sentinel = 'respondWithScriptSpec'
    if ((!((aReader)->ReadSentinel(1605044376)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'respondWithScriptSpec' (nsCString) member of 'FetchEventRespondWithClosure'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_respondWithScriptSpec),
            ::uint32_t{0},
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->respondWithLineNumber())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'respondWithLineNumber | respondWithColumnNumber'
    if ((!((aReader)->ReadSentinel(3238269619)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _fetchHandlerStart = *maybe___fetchHandlerStart;
    // Sentinel = 'fetchHandlerStart'
    if ((!((aReader)->ReadSentinel(1018758871)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerStart' (TimeStamp) member of 'FetchEventTimeStamps'");
        return {};
    }
    auto maybe___fetchHandlerFinish = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___fetchHandlerFinish) {
        aReader->FatalError("Error deserializing 'fetchHandlerFinish' (TimeStamp) member of 'FetchEventTimeStamps'");
        return {};

    }
    auto& _fetchHandlerFinish = *maybe___fetchHandlerFinish;
    // Sentinel = 'fetchHandlerFinish'
    if ((!((aReader)->ReadSentinel(1133119274)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerFinish' (TimeStamp) member of 'FetchEventTimeStamps'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_fetchHandlerStart),
            std::move(_fetchHandlerFinish)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ChildToParentSynthesizeResponseArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).internalResponse());
    // Sentinel = 'internalResponse'
    (aWriter)->WriteSentinel(951649965);
    IPC::WriteParam(aWriter, (aVar).closure());
    // Sentinel = 'closure'
    (aWriter)->WriteSentinel(199426814);
    IPC::WriteParam(aWriter, (aVar).timeStamps());
    // Sentinel = 'timeStamps'
    (aWriter)->WriteSentinel(381813800);
}

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

    }
    auto& _internalResponse = *maybe___internalResponse;
    // Sentinel = 'internalResponse'
    if ((!((aReader)->ReadSentinel(951649965)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'internalResponse' (ChildToParentInternalResponse) member of 'ChildToParentSynthesizeResponseArgs'");
        return {};
    }
    auto maybe___closure = IPC::ReadParam<::mozilla::dom::FetchEventRespondWithClosure>(aReader);
    if (!maybe___closure) {
        aReader->FatalError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ChildToParentSynthesizeResponseArgs'");
        return {};

    }
    auto& _closure = *maybe___closure;
    // Sentinel = 'closure'
    if ((!((aReader)->ReadSentinel(199426814)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ChildToParentSynthesizeResponseArgs'");
        return {};
    }
    auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
    if (!maybe___timeStamps) {
        aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ChildToParentSynthesizeResponseArgs'");
        return {};

    }
    auto& _timeStamps = *maybe___timeStamps;
    // Sentinel = 'timeStamps'
    if ((!((aReader)->ReadSentinel(381813800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ChildToParentSynthesizeResponseArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_internalResponse),
            std::move(_closure),
            std::move(_timeStamps)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::ParentToParentSynthesizeResponseArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).internalResponse());
    // Sentinel = 'internalResponse'
    (aWriter)->WriteSentinel(951649965);
    IPC::WriteParam(aWriter, (aVar).closure());
    // Sentinel = 'closure'
    (aWriter)->WriteSentinel(199426814);
    IPC::WriteParam(aWriter, (aVar).timeStamps());
    // Sentinel = 'timeStamps'
    (aWriter)->WriteSentinel(381813800);
}

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

    }
    auto& _internalResponse = *maybe___internalResponse;
    // Sentinel = 'internalResponse'
    if ((!((aReader)->ReadSentinel(951649965)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'internalResponse' (ParentToParentInternalResponse) member of 'ParentToParentSynthesizeResponseArgs'");
        return {};
    }
    auto maybe___closure = IPC::ReadParam<::mozilla::dom::FetchEventRespondWithClosure>(aReader);
    if (!maybe___closure) {
        aReader->FatalError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ParentToParentSynthesizeResponseArgs'");
        return {};

    }
    auto& _closure = *maybe___closure;
    // Sentinel = 'closure'
    if ((!((aReader)->ReadSentinel(199426814)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'closure' (FetchEventRespondWithClosure) member of 'ParentToParentSynthesizeResponseArgs'");
        return {};
    }
    auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
    if (!maybe___timeStamps) {
        aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ParentToParentSynthesizeResponseArgs'");
        return {};

    }
    auto& _timeStamps = *maybe___timeStamps;
    // Sentinel = 'timeStamps'
    if ((!((aReader)->ReadSentinel(381813800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ParentToParentSynthesizeResponseArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_internalResponse),
            std::move(_closure),
            std::move(_timeStamps)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _timeStamps = *maybe___timeStamps;
    // Sentinel = 'timeStamps'
    if ((!((aReader)->ReadSentinel(381813800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'ResetInterceptionArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_timeStamps)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _status = *maybe___status;
    // Sentinel = 'status'
    if ((!((aReader)->ReadSentinel(154731173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'CancelInterceptionArgs'");
        return {};
    }
    auto maybe___timeStamps = IPC::ReadParam<::mozilla::dom::FetchEventTimeStamps>(aReader);
    if (!maybe___timeStamps) {
        aReader->FatalError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'CancelInterceptionArgs'");
        return {};

    }
    auto& _timeStamps = *maybe___timeStamps;
    // Sentinel = 'timeStamps'
    if ((!((aReader)->ReadSentinel(381813800)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timeStamps' (FetchEventTimeStamps) member of 'CancelInterceptionArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_status),
            std::move(_timeStamps)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ChildToParentFetchEventRespondWithResult|
//
namespace mozilla {
namespace dom {
auto ChildToParentFetchEventRespondWithResult::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TChildToParentSynthesizeResponseArgs:
        {
            (ptr_ChildToParentSynthesizeResponseArgs())->~ChildToParentSynthesizeResponseArgs__tdef();
            break;
        }
    case TResetInterceptionArgs:
        {
            (ptr_ResetInterceptionArgs())->~ResetInterceptionArgs__tdef();
            break;
        }
    case TCancelInterceptionArgs:
        {
            (ptr_CancelInterceptionArgs())->~CancelInterceptionArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ChildToParentSynthesizeResponseArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(aOther);
    mType = TChildToParentSynthesizeResponseArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ChildToParentSynthesizeResponseArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move(aOther));
    mType = TChildToParentSynthesizeResponseArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ResetInterceptionArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aOther);
    mType = TResetInterceptionArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ResetInterceptionArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aOther));
    mType = TResetInterceptionArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const CancelInterceptionArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aOther);
    mType = TCancelInterceptionArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(CancelInterceptionArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aOther));
    mType = TCancelInterceptionArgs;
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(const ChildToParentFetchEventRespondWithResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TChildToParentSynthesizeResponseArgs:
        {
            new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs((aOther).get_ChildToParentSynthesizeResponseArgs());
            break;
        }
    case TResetInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aOther).get_ResetInterceptionArgs());
            break;
        }
    case TCancelInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aOther).get_CancelInterceptionArgs());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ChildToParentFetchEventRespondWithResult::ChildToParentFetchEventRespondWithResult(ChildToParentFetchEventRespondWithResult&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TChildToParentSynthesizeResponseArgs:
        {
            new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move((aOther).get_ChildToParentSynthesizeResponseArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TResetInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aOther).get_ResetInterceptionArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCancelInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aOther).get_CancelInterceptionArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ChildToParentFetchEventRespondWithResult::operator=(const ChildToParentSynthesizeResponseArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(aRhs);
    mType = TChildToParentSynthesizeResponseArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(ChildToParentSynthesizeResponseArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move(aRhs));
    mType = TChildToParentSynthesizeResponseArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(const ResetInterceptionArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aRhs);
    mType = TResetInterceptionArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(ResetInterceptionArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aRhs));
    mType = TResetInterceptionArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(const CancelInterceptionArgs& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aRhs);
    mType = TCancelInterceptionArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(CancelInterceptionArgs&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aRhs));
    mType = TCancelInterceptionArgs;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(const ChildToParentFetchEventRespondWithResult& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TChildToParentSynthesizeResponseArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs((aRhs).get_ChildToParentSynthesizeResponseArgs());
            break;
        }
    case TResetInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aRhs).get_ResetInterceptionArgs());
            break;
        }
    case TCancelInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aRhs).get_CancelInterceptionArgs());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto ChildToParentFetchEventRespondWithResult::operator=(ChildToParentFetchEventRespondWithResult&& aRhs) -> ChildToParentFetchEventRespondWithResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TChildToParentSynthesizeResponseArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ChildToParentSynthesizeResponseArgs()) ChildToParentSynthesizeResponseArgs(std::move((aRhs).get_ChildToParentSynthesizeResponseArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TResetInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aRhs).get_ResetInterceptionArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCancelInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aRhs).get_CancelInterceptionArgs()));
            (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::ChildToParentFetchEventRespondWithResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ChildToParentFetchEventRespondWithResult union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ChildToParentFetchEventRespondWithResult'
    (aWriter)->WriteSentinel(1078464500);

    switch (type) {
    case union__::TChildToParentSynthesizeResponseArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ChildToParentSynthesizeResponseArgs());
            // Sentinel = 'TChildToParentSynthesizeResponseArgs'
            (aWriter)->WriteSentinel(108859000);
            return;
        }
    case union__::TResetInterceptionArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ResetInterceptionArgs());
            // Sentinel = 'TResetInterceptionArgs'
            (aWriter)->WriteSentinel(1678969049);
            return;
        }
    case union__::TCancelInterceptionArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CancelInterceptionArgs());
            // Sentinel = 'TCancelInterceptionArgs'
            (aWriter)->WriteSentinel(1784744220);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ChildToParentFetchEventRespondWithResult");
            return;
        }
    }
}

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

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

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

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ParentToParentFetchEventRespondWithResult|
//
namespace mozilla {
namespace dom {
auto ParentToParentFetchEventRespondWithResult::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TParentToParentSynthesizeResponseArgs:
        {
            (ptr_ParentToParentSynthesizeResponseArgs())->~ParentToParentSynthesizeResponseArgs__tdef();
            break;
        }
    case TResetInterceptionArgs:
        {
            (ptr_ResetInterceptionArgs())->~ResetInterceptionArgs__tdef();
            break;
        }
    case TCancelInterceptionArgs:
        {
            (ptr_CancelInterceptionArgs())->~CancelInterceptionArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ParentToParentSynthesizeResponseArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(aOther);
    mType = TParentToParentSynthesizeResponseArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ParentToParentSynthesizeResponseArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move(aOther));
    mType = TParentToParentSynthesizeResponseArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ResetInterceptionArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aOther);
    mType = TResetInterceptionArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ResetInterceptionArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aOther));
    mType = TResetInterceptionArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const CancelInterceptionArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aOther);
    mType = TCancelInterceptionArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(CancelInterceptionArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aOther));
    mType = TCancelInterceptionArgs;
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(const ParentToParentFetchEventRespondWithResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TParentToParentSynthesizeResponseArgs:
        {
            new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs((aOther).get_ParentToParentSynthesizeResponseArgs());
            break;
        }
    case TResetInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aOther).get_ResetInterceptionArgs());
            break;
        }
    case TCancelInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aOther).get_CancelInterceptionArgs());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ParentToParentFetchEventRespondWithResult::ParentToParentFetchEventRespondWithResult(ParentToParentFetchEventRespondWithResult&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TParentToParentSynthesizeResponseArgs:
        {
            new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move((aOther).get_ParentToParentSynthesizeResponseArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TResetInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aOther).get_ResetInterceptionArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCancelInterceptionArgs:
        {
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aOther).get_CancelInterceptionArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto ParentToParentFetchEventRespondWithResult::operator=(const ParentToParentSynthesizeResponseArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(aRhs);
    mType = TParentToParentSynthesizeResponseArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(ParentToParentSynthesizeResponseArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move(aRhs));
    mType = TParentToParentSynthesizeResponseArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(const ResetInterceptionArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(aRhs);
    mType = TResetInterceptionArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(ResetInterceptionArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move(aRhs));
    mType = TResetInterceptionArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(const CancelInterceptionArgs& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(aRhs);
    mType = TCancelInterceptionArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(CancelInterceptionArgs&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move(aRhs));
    mType = TCancelInterceptionArgs;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(const ParentToParentFetchEventRespondWithResult& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TParentToParentSynthesizeResponseArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs((aRhs).get_ParentToParentSynthesizeResponseArgs());
            break;
        }
    case TResetInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs((aRhs).get_ResetInterceptionArgs());
            break;
        }
    case TCancelInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs((aRhs).get_CancelInterceptionArgs());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto ParentToParentFetchEventRespondWithResult::operator=(ParentToParentFetchEventRespondWithResult&& aRhs) -> ParentToParentFetchEventRespondWithResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TParentToParentSynthesizeResponseArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ParentToParentSynthesizeResponseArgs()) ParentToParentSynthesizeResponseArgs(std::move((aRhs).get_ParentToParentSynthesizeResponseArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TResetInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ResetInterceptionArgs()) ResetInterceptionArgs(std::move((aRhs).get_ResetInterceptionArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCancelInterceptionArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CancelInterceptionArgs()) CancelInterceptionArgs(std::move((aRhs).get_CancelInterceptionArgs()));
            (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::ParentToParentFetchEventRespondWithResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ParentToParentFetchEventRespondWithResult union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ParentToParentFetchEventRespondWithResult'
    (aWriter)->WriteSentinel(1430327418);

    switch (type) {
    case union__::TParentToParentSynthesizeResponseArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ParentToParentSynthesizeResponseArgs());
            // Sentinel = 'TParentToParentSynthesizeResponseArgs'
            (aWriter)->WriteSentinel(422317822);
            return;
        }
    case union__::TResetInterceptionArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_ResetInterceptionArgs());
            // Sentinel = 'TResetInterceptionArgs'
            (aWriter)->WriteSentinel(1678969049);
            return;
        }
    case union__::TCancelInterceptionArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CancelInterceptionArgs());
            // Sentinel = 'TCancelInterceptionArgs'
            (aWriter)->WriteSentinel(1784744220);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ParentToParentFetchEventRespondWithResult");
            return;
        }
    }
}

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

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

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _workerScriptExecutedSuccessfully = *maybe___workerScriptExecutedSuccessfully;
    // Sentinel = 'workerScriptExecutedSuccessfully'
    if ((!((aReader)->ReadSentinel(3669167436)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'workerScriptExecutedSuccessfully' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
        return {};
    }
    auto maybe___fetchHandlerWasAdded = IPC::ReadParam<bool>(aReader);
    if (!maybe___fetchHandlerWasAdded) {
        aReader->FatalError("Error deserializing 'fetchHandlerWasAdded' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
        return {};

    }
    auto& _fetchHandlerWasAdded = *maybe___fetchHandlerWasAdded;
    // Sentinel = 'fetchHandlerWasAdded'
    if ((!((aReader)->ReadSentinel(1382680518)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fetchHandlerWasAdded' (bool) member of 'ServiceWorkerCheckScriptEvaluationOpResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_workerScriptExecutedSuccessfully),
            std::move(_fetchHandlerWasAdded)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _rv = *maybe___rv;
    // Sentinel = 'rv'
    if ((!((aReader)->ReadSentinel(22806761)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rv' (nsresult) member of 'ServiceWorkerFetchEventOpResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rv)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _extensionAPIEventListenerWasAdded = *maybe___extensionAPIEventListenerWasAdded;
    // Sentinel = 'extensionAPIEventListenerWasAdded'
    if ((!((aReader)->ReadSentinel(3745910013)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'extensionAPIEventListenerWasAdded' (bool) member of 'ServiceWorkerExtensionAPIEventOpResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_extensionAPIEventListenerWasAdded)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union ServiceWorkerOpResult|
//
namespace mozilla {
namespace dom {
auto ServiceWorkerOpResult::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TServiceWorkerCheckScriptEvaluationOpResult:
        {
            (ptr_ServiceWorkerCheckScriptEvaluationOpResult())->~ServiceWorkerCheckScriptEvaluationOpResult__tdef();
            break;
        }
    case TServiceWorkerFetchEventOpResult:
        {
            (ptr_ServiceWorkerFetchEventOpResult())->~ServiceWorkerFetchEventOpResult__tdef();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpResult:
        {
            (ptr_ServiceWorkerExtensionAPIEventOpResult())->~ServiceWorkerExtensionAPIEventOpResult__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerCheckScriptEvaluationOpResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(aOther);
    mType = TServiceWorkerCheckScriptEvaluationOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerCheckScriptEvaluationOpResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move(aOther));
    mType = TServiceWorkerCheckScriptEvaluationOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerFetchEventOpResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(aOther);
    mType = TServiceWorkerFetchEventOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerFetchEventOpResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move(aOther));
    mType = TServiceWorkerFetchEventOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerExtensionAPIEventOpResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(aOther);
    mType = TServiceWorkerExtensionAPIEventOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerExtensionAPIEventOpResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move(aOther));
    mType = TServiceWorkerExtensionAPIEventOpResult;
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(const ServiceWorkerOpResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TServiceWorkerCheckScriptEvaluationOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult((aOther).get_ServiceWorkerCheckScriptEvaluationOpResult());
            break;
        }
    case TServiceWorkerFetchEventOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult((aOther).get_ServiceWorkerFetchEventOpResult());
            break;
        }
    case TServiceWorkerExtensionAPIEventOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult((aOther).get_ServiceWorkerExtensionAPIEventOpResult());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT ServiceWorkerOpResult::ServiceWorkerOpResult(ServiceWorkerOpResult&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerCheckScriptEvaluationOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move((aOther).get_ServiceWorkerCheckScriptEvaluationOpResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerFetchEventOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move((aOther).get_ServiceWorkerFetchEventOpResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpResult:
        {
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move((aOther).get_ServiceWorkerExtensionAPIEventOpResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto ServiceWorkerOpResult::operator=(const ServiceWorkerCheckScriptEvaluationOpResult& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(aRhs);
    mType = TServiceWorkerCheckScriptEvaluationOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(ServiceWorkerCheckScriptEvaluationOpResult&& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move(aRhs));
    mType = TServiceWorkerCheckScriptEvaluationOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(const ServiceWorkerFetchEventOpResult& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(aRhs);
    mType = TServiceWorkerFetchEventOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(ServiceWorkerFetchEventOpResult&& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move(aRhs));
    mType = TServiceWorkerFetchEventOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(const ServiceWorkerExtensionAPIEventOpResult& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(aRhs);
    mType = TServiceWorkerExtensionAPIEventOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(ServiceWorkerExtensionAPIEventOpResult&& aRhs) -> ServiceWorkerOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move(aRhs));
    mType = TServiceWorkerExtensionAPIEventOpResult;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(const ServiceWorkerOpResult& aRhs) -> ServiceWorkerOpResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TServiceWorkerCheckScriptEvaluationOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult((aRhs).get_ServiceWorkerCheckScriptEvaluationOpResult());
            break;
        }
    case TServiceWorkerFetchEventOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult((aRhs).get_ServiceWorkerFetchEventOpResult());
            break;
        }
    case TServiceWorkerExtensionAPIEventOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult((aRhs).get_ServiceWorkerExtensionAPIEventOpResult());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto ServiceWorkerOpResult::operator=(ServiceWorkerOpResult&& aRhs) -> ServiceWorkerOpResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerCheckScriptEvaluationOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerCheckScriptEvaluationOpResult()) ServiceWorkerCheckScriptEvaluationOpResult(std::move((aRhs).get_ServiceWorkerCheckScriptEvaluationOpResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerFetchEventOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerFetchEventOpResult()) ServiceWorkerFetchEventOpResult(std::move((aRhs).get_ServiceWorkerFetchEventOpResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TServiceWorkerExtensionAPIEventOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ServiceWorkerExtensionAPIEventOpResult()) ServiceWorkerExtensionAPIEventOpResult(std::move((aRhs).get_ServiceWorkerExtensionAPIEventOpResult()));
            (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::ServiceWorkerOpResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::ServiceWorkerOpResult union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'ServiceWorkerOpResult'
    (aWriter)->WriteSentinel(1556875402);

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TServiceWorkerCheckScriptEvaluationOpResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerCheckScriptEvaluationOpResult());
            // Sentinel = 'TServiceWorkerCheckScriptEvaluationOpResult'
            (aWriter)->WriteSentinel(2001932617);
            return;
        }
    case union__::TServiceWorkerFetchEventOpResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerFetchEventOpResult());
            // Sentinel = 'TServiceWorkerFetchEventOpResult'
            (aWriter)->WriteSentinel(3496152266);
            return;
        }
    case union__::TServiceWorkerExtensionAPIEventOpResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_ServiceWorkerExtensionAPIEventOpResult());
            // Sentinel = 'TServiceWorkerExtensionAPIEventOpResult'
            (aWriter)->WriteSentinel(875695991);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union ServiceWorkerOpResult");
            return;
        }
    }
}

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

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

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

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

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

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

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

} // namespace IPC
