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


#include "mozilla/dom/cache/IPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/dom/cache/PCacheParent.h"
#include "mozilla/dom/cache/PCacheChild.h"
#include "mozilla/dom/cache/PCacheStreamControlParent.h"
#include "mozilla/dom/cache/PCacheStreamControlChild.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/cache/CacheTypes.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 CacheQueryParams|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheQueryParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).ignoreSearch());
    // Sentinel = 'ignoreSearch'
    (aWriter)->WriteSentinel(534643931);
    IPC::WriteParam(aWriter, (aVar).ignoreMethod());
    // Sentinel = 'ignoreMethod'
    (aWriter)->WriteSentinel(536610022);
    IPC::WriteParam(aWriter, (aVar).ignoreVary());
    // Sentinel = 'ignoreVary'
    (aWriter)->WriteSentinel(381223975);
    IPC::WriteParam(aWriter, (aVar).cacheNameSet());
    // Sentinel = 'cacheNameSet'
    (aWriter)->WriteSentinel(501023906);
    IPC::WriteParam(aWriter, (aVar).cacheName());
    // Sentinel = 'cacheName'
    (aWriter)->WriteSentinel(289670006);
}

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

    }
    auto& _ignoreSearch = *maybe___ignoreSearch;
    // Sentinel = 'ignoreSearch'
    if ((!((aReader)->ReadSentinel(534643931)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ignoreSearch' (bool) member of 'CacheQueryParams'");
        return {};
    }
    auto maybe___ignoreMethod = IPC::ReadParam<bool>(aReader);
    if (!maybe___ignoreMethod) {
        aReader->FatalError("Error deserializing 'ignoreMethod' (bool) member of 'CacheQueryParams'");
        return {};

    }
    auto& _ignoreMethod = *maybe___ignoreMethod;
    // Sentinel = 'ignoreMethod'
    if ((!((aReader)->ReadSentinel(536610022)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ignoreMethod' (bool) member of 'CacheQueryParams'");
        return {};
    }
    auto maybe___ignoreVary = IPC::ReadParam<bool>(aReader);
    if (!maybe___ignoreVary) {
        aReader->FatalError("Error deserializing 'ignoreVary' (bool) member of 'CacheQueryParams'");
        return {};

    }
    auto& _ignoreVary = *maybe___ignoreVary;
    // Sentinel = 'ignoreVary'
    if ((!((aReader)->ReadSentinel(381223975)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ignoreVary' (bool) member of 'CacheQueryParams'");
        return {};
    }
    auto maybe___cacheNameSet = IPC::ReadParam<bool>(aReader);
    if (!maybe___cacheNameSet) {
        aReader->FatalError("Error deserializing 'cacheNameSet' (bool) member of 'CacheQueryParams'");
        return {};

    }
    auto& _cacheNameSet = *maybe___cacheNameSet;
    // Sentinel = 'cacheNameSet'
    if ((!((aReader)->ReadSentinel(501023906)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheNameSet' (bool) member of 'CacheQueryParams'");
        return {};
    }
    auto maybe___cacheName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___cacheName) {
        aReader->FatalError("Error deserializing 'cacheName' (nsString) member of 'CacheQueryParams'");
        return {};

    }
    auto& _cacheName = *maybe___cacheName;
    // Sentinel = 'cacheName'
    if ((!((aReader)->ReadSentinel(289670006)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheName' (nsString) member of 'CacheQueryParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_ignoreSearch),
            std::move(_ignoreMethod),
            std::move(_ignoreVary),
            std::move(_cacheNameSet),
            std::move(_cacheName)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'CacheReadStream'");
        return {};
    }
    auto maybe___control = IPC::ReadParam<::mozilla::ipc::SideVariant<::mozilla::dom::cache::PCacheStreamControlParent*, ::mozilla::dom::cache::PCacheStreamControlChild*>>(aReader);
    if (!maybe___control) {
        aReader->FatalError("Error deserializing 'control' (PCacheStreamControl) member of 'CacheReadStream'");
        return {};

    }
    auto& _control = *maybe___control;
    // Sentinel = 'control'
    if ((!((aReader)->ReadSentinel(200016642)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'control' (PCacheStreamControl) member of 'CacheReadStream'");
        return {};
    }
    auto maybe___stream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
    if (!maybe___stream) {
        aReader->FatalError("Error deserializing 'stream' (IPCStream?) member of 'CacheReadStream'");
        return {};

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

} // namespace IPC

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).method());
    // Sentinel = 'method'
    (aWriter)->WriteSentinel(148308610);
    IPC::WriteParam(aWriter, (aVar).urlWithoutQuery());
    // Sentinel = 'urlWithoutQuery'
    (aWriter)->WriteSentinel(851510878);
    IPC::WriteParam(aWriter, (aVar).urlQuery());
    // Sentinel = 'urlQuery'
    (aWriter)->WriteSentinel(256574314);
    IPC::WriteParam(aWriter, (aVar).urlFragment());
    // Sentinel = 'urlFragment'
    (aWriter)->WriteSentinel(454821000);
    IPC::WriteParam(aWriter, (aVar).headers());
    // Sentinel = 'headers'
    (aWriter)->WriteSentinel(188220125);
    IPC::WriteParam(aWriter, (aVar).headersGuard());
    // Sentinel = 'headersGuard'
    (aWriter)->WriteSentinel(522912976);
    IPC::WriteParam(aWriter, (aVar).referrer());
    // Sentinel = 'referrer'
    (aWriter)->WriteSentinel(252838750);
    IPC::WriteParam(aWriter, (aVar).referrerPolicy());
    // Sentinel = 'referrerPolicy'
    (aWriter)->WriteSentinel(729482702);
    IPC::WriteParam(aWriter, (aVar).mode());
    // Sentinel = 'mode'
    (aWriter)->WriteSentinel(70386086);
    IPC::WriteParam(aWriter, (aVar).credentials());
    // Sentinel = 'credentials'
    (aWriter)->WriteSentinel(454689935);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).contentPolicyType());
    // Sentinel = 'contentPolicyType'
    (aWriter)->WriteSentinel(1066927886);
    IPC::WriteParam(aWriter, (aVar).requestCache());
    // Sentinel = 'requestCache'
    (aWriter)->WriteSentinel(544736478);
    IPC::WriteParam(aWriter, (aVar).requestRedirect());
    // Sentinel = 'requestRedirect'
    (aWriter)->WriteSentinel(843974204);
    IPC::WriteParam(aWriter, (aVar).integrity());
    // Sentinel = 'integrity'
    (aWriter)->WriteSentinel(320537568);
    IPC::WriteParam(aWriter, (aVar).loadingEmbedderPolicy());
    // Sentinel = 'loadingEmbedderPolicy'
    (aWriter)->WriteSentinel(1541343335);
    IPC::WriteParam(aWriter, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aWriter)->WriteSentinel(633472335);
    (aWriter)->WriteBytes((&((aVar).bodyDiskSize())), 8);
    // Sentinel = 'bodyDiskSize'
    (aWriter)->WriteSentinel(523896021);
}

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

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

    }
    auto& _urlWithoutQuery = *maybe___urlWithoutQuery;
    // Sentinel = 'urlWithoutQuery'
    if ((!((aReader)->ReadSentinel(851510878)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlWithoutQuery' (nsCString) member of 'CacheRequest'");
        return {};
    }
    auto maybe___urlQuery = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___urlQuery) {
        aReader->FatalError("Error deserializing 'urlQuery' (nsCString) member of 'CacheRequest'");
        return {};

    }
    auto& _urlQuery = *maybe___urlQuery;
    // Sentinel = 'urlQuery'
    if ((!((aReader)->ReadSentinel(256574314)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlQuery' (nsCString) member of 'CacheRequest'");
        return {};
    }
    auto maybe___urlFragment = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___urlFragment) {
        aReader->FatalError("Error deserializing 'urlFragment' (nsCString) member of 'CacheRequest'");
        return {};

    }
    auto& _urlFragment = *maybe___urlFragment;
    // Sentinel = 'urlFragment'
    if ((!((aReader)->ReadSentinel(454821000)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'urlFragment' (nsCString) member of 'CacheRequest'");
        return {};
    }
    auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::cache::HeadersEntry>>(aReader);
    if (!maybe___headers) {
        aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheRequest'");
        return {};

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

    }
    auto& _headersGuard = *maybe___headersGuard;
    // Sentinel = 'headersGuard'
    if ((!((aReader)->ReadSentinel(522912976)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheRequest'");
        return {};
    }
    auto maybe___referrer = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___referrer) {
        aReader->FatalError("Error deserializing 'referrer' (nsCString) member of 'CacheRequest'");
        return {};

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

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

    }
    auto& _mode = *maybe___mode;
    // Sentinel = 'mode'
    if ((!((aReader)->ReadSentinel(70386086)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'mode' (RequestMode) member of 'CacheRequest'");
        return {};
    }
    auto maybe___credentials = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
    if (!maybe___credentials) {
        aReader->FatalError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheRequest'");
        return {};

    }
    auto& _credentials = *maybe___credentials;
    // Sentinel = 'credentials'
    if ((!((aReader)->ReadSentinel(454689935)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheRequest'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheReadStream>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (CacheReadStream?) member of 'CacheRequest'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (CacheReadStream?) member of 'CacheRequest'");
        return {};
    }
    auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
    if (!maybe___contentPolicyType) {
        aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'CacheRequest'");
        return {};

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

    }
    auto& _requestCache = *maybe___requestCache;
    // Sentinel = 'requestCache'
    if ((!((aReader)->ReadSentinel(544736478)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestCache' (RequestCache) member of 'CacheRequest'");
        return {};
    }
    auto maybe___requestRedirect = IPC::ReadParam<::mozilla::dom::RequestRedirect>(aReader);
    if (!maybe___requestRedirect) {
        aReader->FatalError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'CacheRequest'");
        return {};

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

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

    }
    auto& _loadingEmbedderPolicy = *maybe___loadingEmbedderPolicy;
    // Sentinel = 'loadingEmbedderPolicy'
    if ((!((aReader)->ReadSentinel(1541343335)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'loadingEmbedderPolicy' (CrossOriginEmbedderPolicy) member of 'CacheRequest'");
        return {};
    }
    auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
    if (!maybe___principalInfo) {
        aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheRequest'");
        return {};

    }
    auto& _principalInfo = *maybe___principalInfo;
    // Sentinel = 'principalInfo'
    if ((!((aReader)->ReadSentinel(633472335)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_method),
            std::move(_urlWithoutQuery),
            std::move(_urlQuery),
            std::move(_urlFragment),
            std::move(_headers),
            std::move(_headersGuard),
            std::move(_referrer),
            std::move(_referrerPolicy),
            std::move(_mode),
            std::move(_credentials),
            std::move(_body),
            ::int64_t{0},
            std::move(_contentPolicyType),
            std::move(_requestCache),
            std::move(_requestRedirect),
            std::move(_integrity),
            std::move(_loadingEmbedderPolicy),
            std::move(_principalInfo)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodyDiskSize())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodyDiskSize'
    if ((!((aReader)->ReadSentinel(523896021)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheResponse|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheResponse::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(CacheResponse, paddingSize_) - offsetof(CacheResponse, bodyDiskSize_)) == 8,
        "Bad assumptions about field layout!");
    static_assert(
        (offsetof(CacheResponse, paddingInfo_) - offsetof(CacheResponse, status_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace cache
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).type());
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
    IPC::WriteParam(aWriter, (aVar).urlList());
    // Sentinel = 'urlList'
    (aWriter)->WriteSentinel(197591792);
    IPC::WriteParam(aWriter, (aVar).statusText());
    // Sentinel = 'statusText'
    (aWriter)->WriteSentinel(397411402);
    IPC::WriteParam(aWriter, (aVar).headers());
    // Sentinel = 'headers'
    (aWriter)->WriteSentinel(188220125);
    IPC::WriteParam(aWriter, (aVar).headersGuard());
    // Sentinel = 'headersGuard'
    (aWriter)->WriteSentinel(522912976);
    IPC::WriteParam(aWriter, (aVar).body());
    // Sentinel = 'body'
    (aWriter)->WriteSentinel(68813231);
    IPC::WriteParam(aWriter, (aVar).securityInfo());
    // Sentinel = 'securityInfo'
    (aWriter)->WriteSentinel(552535301);
    IPC::WriteParam(aWriter, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aWriter)->WriteSentinel(633472335);
    IPC::WriteParam(aWriter, (aVar).credentials());
    // Sentinel = 'credentials'
    (aWriter)->WriteSentinel(454689935);
    (aWriter)->WriteBytes((&((aVar).bodyDiskSize())), 16);
    // Sentinel = 'bodyDiskSize | paddingSize'
    (aWriter)->WriteSentinel(2264926723);
    (aWriter)->WriteBytes((&((aVar).status())), 8);
    // Sentinel = 'status | paddingInfo'
    (aWriter)->WriteSentinel(1378355140);
}

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

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

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

    }
    auto& _statusText = *maybe___statusText;
    // Sentinel = 'statusText'
    if ((!((aReader)->ReadSentinel(397411402)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'statusText' (nsCString) member of 'CacheResponse'");
        return {};
    }
    auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::cache::HeadersEntry>>(aReader);
    if (!maybe___headers) {
        aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheResponse'");
        return {};

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

    }
    auto& _headersGuard = *maybe___headersGuard;
    // Sentinel = 'headersGuard'
    if ((!((aReader)->ReadSentinel(522912976)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheResponse'");
        return {};
    }
    auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheReadStream>>(aReader);
    if (!maybe___body) {
        aReader->FatalError("Error deserializing 'body' (CacheReadStream?) member of 'CacheResponse'");
        return {};

    }
    auto& _body = *maybe___body;
    // Sentinel = 'body'
    if ((!((aReader)->ReadSentinel(68813231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'body' (CacheReadStream?) member of 'CacheResponse'");
        return {};
    }
    auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
    if (!maybe___securityInfo) {
        aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'CacheResponse'");
        return {};

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

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

    }
    auto& _credentials = *maybe___credentials;
    // Sentinel = 'credentials'
    if ((!((aReader)->ReadSentinel(454689935)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_type),
            std::move(_urlList),
            ::uint32_t{0},
            std::move(_statusText),
            std::move(_headers),
            std::move(_headersGuard),
            std::move(_body),
            ::int64_t{0},
            std::move(_securityInfo),
            std::move(_principalInfo),
            ::uint32_t{0},
            ::int64_t{0},
            std::move(_credentials)};
    if ((!((aReader)->ReadBytesInto((&((result__)->bodyDiskSize())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'bodyDiskSize | paddingSize'
    if ((!((aReader)->ReadSentinel(2264926723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->status())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'status | paddingInfo'
    if ((!((aReader)->ReadSentinel(1378355140)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheRequestResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).request());
    // Sentinel = 'request'
    (aWriter)->WriteSentinel(202703626);
    IPC::WriteParam(aWriter, (aVar).response());
    // Sentinel = 'response'
    (aWriter)->WriteSentinel(260965232);
}

auto ParamTraits<::mozilla::dom::cache::CacheRequestResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
    if (!maybe___request) {
        aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheRequestResponse'");
        return {};

    }
    auto& _request = *maybe___request;
    // Sentinel = 'request'
    if ((!((aReader)->ReadSentinel(202703626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheRequestResponse'");
        return {};
    }
    auto maybe___response = IPC::ReadParam<::mozilla::dom::cache::CacheResponse>(aReader);
    if (!maybe___response) {
        aReader->FatalError("Error deserializing 'response' (CacheResponse) member of 'CacheRequestResponse'");
        return {};

    }
    auto& _response = *maybe___response;
    // Sentinel = 'response'
    if ((!((aReader)->ReadSentinel(260965232)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'response' (CacheResponse) member of 'CacheRequestResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_request),
            std::move(_response)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).request());
    // Sentinel = 'request'
    (aWriter)->WriteSentinel(202703626);
    IPC::WriteParam(aWriter, (aVar).params());
    // Sentinel = 'params'
    (aWriter)->WriteSentinel(146997893);
    IPC::WriteParam(aWriter, (aVar).openMode());
    // Sentinel = 'openMode'
    (aWriter)->WriteSentinel(247595832);
}

auto ParamTraits<::mozilla::dom::cache::CacheMatchArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
    if (!maybe___request) {
        aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheMatchArgs'");
        return {};

    }
    auto& _request = *maybe___request;
    // Sentinel = 'request'
    if ((!((aReader)->ReadSentinel(202703626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheMatchArgs'");
        return {};
    }
    auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
    if (!maybe___params) {
        aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchArgs'");
        return {};

    }
    auto& _params = *maybe___params;
    // Sentinel = 'params'
    if ((!((aReader)->ReadSentinel(146997893)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchArgs'");
        return {};
    }
    auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
    if (!maybe___openMode) {
        aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchArgs'");
        return {};

    }
    auto& _openMode = *maybe___openMode;
    // Sentinel = 'openMode'
    if ((!((aReader)->ReadSentinel(247595832)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_request),
            std::move(_params),
            std::move(_openMode)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchAllArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).maybeRequest());
    // Sentinel = 'maybeRequest'
    (aWriter)->WriteSentinel(534054136);
    IPC::WriteParam(aWriter, (aVar).params());
    // Sentinel = 'params'
    (aWriter)->WriteSentinel(146997893);
    IPC::WriteParam(aWriter, (aVar).openMode());
    // Sentinel = 'openMode'
    (aWriter)->WriteSentinel(247595832);
}

auto ParamTraits<::mozilla::dom::cache::CacheMatchAllArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___maybeRequest = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheRequest>>(aReader);
    if (!maybe___maybeRequest) {
        aReader->FatalError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheMatchAllArgs'");
        return {};

    }
    auto& _maybeRequest = *maybe___maybeRequest;
    // Sentinel = 'maybeRequest'
    if ((!((aReader)->ReadSentinel(534054136)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheMatchAllArgs'");
        return {};
    }
    auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
    if (!maybe___params) {
        aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchAllArgs'");
        return {};

    }
    auto& _params = *maybe___params;
    // Sentinel = 'params'
    if ((!((aReader)->ReadSentinel(146997893)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchAllArgs'");
        return {};
    }
    auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
    if (!maybe___openMode) {
        aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchAllArgs'");
        return {};

    }
    auto& _openMode = *maybe___openMode;
    // Sentinel = 'openMode'
    if ((!((aReader)->ReadSentinel(247595832)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchAllArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_maybeRequest),
            std::move(_params),
            std::move(_openMode)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::CachePutAllArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestResponseList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheRequestResponse>>(aReader);
    if (!maybe___requestResponseList) {
        aReader->FatalError("Error deserializing 'requestResponseList' (CacheRequestResponse[]) member of 'CachePutAllArgs'");
        return {};

    }
    auto& _requestResponseList = *maybe___requestResponseList;
    // Sentinel = 'requestResponseList'
    if ((!((aReader)->ReadSentinel(1343490037)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestResponseList' (CacheRequestResponse[]) member of 'CachePutAllArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestResponseList)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheDeleteArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).request());
    // Sentinel = 'request'
    (aWriter)->WriteSentinel(202703626);
    IPC::WriteParam(aWriter, (aVar).params());
    // Sentinel = 'params'
    (aWriter)->WriteSentinel(146997893);
}

auto ParamTraits<::mozilla::dom::cache::CacheDeleteArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
    if (!maybe___request) {
        aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheDeleteArgs'");
        return {};

    }
    auto& _request = *maybe___request;
    // Sentinel = 'request'
    if ((!((aReader)->ReadSentinel(202703626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheDeleteArgs'");
        return {};
    }
    auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
    if (!maybe___params) {
        aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheDeleteArgs'");
        return {};

    }
    auto& _params = *maybe___params;
    // Sentinel = 'params'
    if ((!((aReader)->ReadSentinel(146997893)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheDeleteArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_request),
            std::move(_params)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheKeysArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).maybeRequest());
    // Sentinel = 'maybeRequest'
    (aWriter)->WriteSentinel(534054136);
    IPC::WriteParam(aWriter, (aVar).params());
    // Sentinel = 'params'
    (aWriter)->WriteSentinel(146997893);
    IPC::WriteParam(aWriter, (aVar).openMode());
    // Sentinel = 'openMode'
    (aWriter)->WriteSentinel(247595832);
}

auto ParamTraits<::mozilla::dom::cache::CacheKeysArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___maybeRequest = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheRequest>>(aReader);
    if (!maybe___maybeRequest) {
        aReader->FatalError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheKeysArgs'");
        return {};

    }
    auto& _maybeRequest = *maybe___maybeRequest;
    // Sentinel = 'maybeRequest'
    if ((!((aReader)->ReadSentinel(534054136)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheKeysArgs'");
        return {};
    }
    auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
    if (!maybe___params) {
        aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheKeysArgs'");
        return {};

    }
    auto& _params = *maybe___params;
    // Sentinel = 'params'
    if ((!((aReader)->ReadSentinel(146997893)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheKeysArgs'");
        return {};
    }
    auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
    if (!maybe___openMode) {
        aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheKeysArgs'");
        return {};

    }
    auto& _openMode = *maybe___openMode;
    // Sentinel = 'openMode'
    if ((!((aReader)->ReadSentinel(247595832)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheKeysArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_maybeRequest),
            std::move(_params),
            std::move(_openMode)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageMatchArgs>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).request());
    // Sentinel = 'request'
    (aWriter)->WriteSentinel(202703626);
    IPC::WriteParam(aWriter, (aVar).params());
    // Sentinel = 'params'
    (aWriter)->WriteSentinel(146997893);
    IPC::WriteParam(aWriter, (aVar).openMode());
    // Sentinel = 'openMode'
    (aWriter)->WriteSentinel(247595832);
}

auto ParamTraits<::mozilla::dom::cache::StorageMatchArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
    if (!maybe___request) {
        aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'StorageMatchArgs'");
        return {};

    }
    auto& _request = *maybe___request;
    // Sentinel = 'request'
    if ((!((aReader)->ReadSentinel(202703626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'StorageMatchArgs'");
        return {};
    }
    auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
    if (!maybe___params) {
        aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'StorageMatchArgs'");
        return {};

    }
    auto& _params = *maybe___params;
    // Sentinel = 'params'
    if ((!((aReader)->ReadSentinel(146997893)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'StorageMatchArgs'");
        return {};
    }
    auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
    if (!maybe___openMode) {
        aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'StorageMatchArgs'");
        return {};

    }
    auto& _openMode = *maybe___openMode;
    // Sentinel = 'openMode'
    if ((!((aReader)->ReadSentinel(247595832)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'StorageMatchArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_request),
            std::move(_params),
            std::move(_openMode)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _key = *maybe___key;
    // Sentinel = 'key'
    if ((!((aReader)->ReadSentinel(42402122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageHasArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_key)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _key = *maybe___key;
    // Sentinel = 'key'
    if ((!((aReader)->ReadSentinel(42402122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageOpenArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_key)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _key = *maybe___key;
    // Sentinel = 'key'
    if ((!((aReader)->ReadSentinel(42402122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageDeleteArgs'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_key)};
    return result__;
}

} // namespace IPC

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CacheOpArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheOpArgs::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TCacheMatchArgs:
        {
            (ptr_CacheMatchArgs())->~CacheMatchArgs__tdef();
            break;
        }
    case TCacheMatchAllArgs:
        {
            (ptr_CacheMatchAllArgs())->~CacheMatchAllArgs__tdef();
            break;
        }
    case TCachePutAllArgs:
        {
            (ptr_CachePutAllArgs())->~CachePutAllArgs__tdef();
            break;
        }
    case TCacheDeleteArgs:
        {
            (ptr_CacheDeleteArgs())->~CacheDeleteArgs__tdef();
            break;
        }
    case TCacheKeysArgs:
        {
            (ptr_CacheKeysArgs())->~CacheKeysArgs__tdef();
            break;
        }
    case TStorageMatchArgs:
        {
            (ptr_StorageMatchArgs())->~StorageMatchArgs__tdef();
            break;
        }
    case TStorageHasArgs:
        {
            (ptr_StorageHasArgs())->~StorageHasArgs__tdef();
            break;
        }
    case TStorageOpenArgs:
        {
            (ptr_StorageOpenArgs())->~StorageOpenArgs__tdef();
            break;
        }
    case TStorageDeleteArgs:
        {
            (ptr_StorageDeleteArgs())->~StorageDeleteArgs__tdef();
            break;
        }
    case TStorageKeysArgs:
        {
            (ptr_StorageKeysArgs())->~StorageKeysArgs__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(aOther);
    mType = TCacheMatchArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheMatchArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move(aOther));
    mType = TCacheMatchArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchAllArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(aOther);
    mType = TCacheMatchAllArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheMatchAllArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move(aOther));
    mType = TCacheMatchAllArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CachePutAllArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(aOther);
    mType = TCachePutAllArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CachePutAllArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move(aOther));
    mType = TCachePutAllArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheDeleteArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(aOther);
    mType = TCacheDeleteArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheDeleteArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move(aOther));
    mType = TCacheDeleteArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheKeysArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(aOther);
    mType = TCacheKeysArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheKeysArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move(aOther));
    mType = TCacheKeysArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageMatchArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(aOther);
    mType = TStorageMatchArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageMatchArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move(aOther));
    mType = TStorageMatchArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageHasArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(aOther);
    mType = TStorageHasArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageHasArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move(aOther));
    mType = TStorageHasArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageOpenArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(aOther);
    mType = TStorageOpenArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageOpenArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move(aOther));
    mType = TStorageOpenArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageDeleteArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(aOther);
    mType = TStorageDeleteArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageDeleteArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move(aOther));
    mType = TStorageDeleteArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageKeysArgs& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(aOther);
    mType = TStorageKeysArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageKeysArgs&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move(aOther));
    mType = TStorageKeysArgs;
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheOpArgs& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TCacheMatchArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs((aOther).get_CacheMatchArgs());
            break;
        }
    case TCacheMatchAllArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs((aOther).get_CacheMatchAllArgs());
            break;
        }
    case TCachePutAllArgs:
        {
            new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs((aOther).get_CachePutAllArgs());
            break;
        }
    case TCacheDeleteArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs((aOther).get_CacheDeleteArgs());
            break;
        }
    case TCacheKeysArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs((aOther).get_CacheKeysArgs());
            break;
        }
    case TStorageMatchArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs((aOther).get_StorageMatchArgs());
            break;
        }
    case TStorageHasArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs((aOther).get_StorageHasArgs());
            break;
        }
    case TStorageOpenArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs((aOther).get_StorageOpenArgs());
            break;
        }
    case TStorageDeleteArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs((aOther).get_StorageDeleteArgs());
            break;
        }
    case TStorageKeysArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs((aOther).get_StorageKeysArgs());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheOpArgs&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TCacheMatchArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move((aOther).get_CacheMatchArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheMatchAllArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move((aOther).get_CacheMatchAllArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCachePutAllArgs:
        {
            new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move((aOther).get_CachePutAllArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheDeleteArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move((aOther).get_CacheDeleteArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheKeysArgs:
        {
            new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move((aOther).get_CacheKeysArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageMatchArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move((aOther).get_StorageMatchArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageHasArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move((aOther).get_StorageHasArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageOpenArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move((aOther).get_StorageOpenArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageDeleteArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move((aOther).get_StorageDeleteArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageKeysArgs:
        {
            new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move((aOther).get_StorageKeysArgs()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto CacheOpArgs::operator=(const CacheMatchArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(aRhs);
    mType = TCacheMatchArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(CacheMatchArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move(aRhs));
    mType = TCacheMatchArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const CacheMatchAllArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(aRhs);
    mType = TCacheMatchAllArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(CacheMatchAllArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move(aRhs));
    mType = TCacheMatchAllArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const CachePutAllArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(aRhs);
    mType = TCachePutAllArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(CachePutAllArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move(aRhs));
    mType = TCachePutAllArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const CacheDeleteArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(aRhs);
    mType = TCacheDeleteArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(CacheDeleteArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move(aRhs));
    mType = TCacheDeleteArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const CacheKeysArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(aRhs);
    mType = TCacheKeysArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(CacheKeysArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move(aRhs));
    mType = TCacheKeysArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const StorageMatchArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(aRhs);
    mType = TStorageMatchArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(StorageMatchArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move(aRhs));
    mType = TStorageMatchArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const StorageHasArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(aRhs);
    mType = TStorageHasArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(StorageHasArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move(aRhs));
    mType = TStorageHasArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const StorageOpenArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(aRhs);
    mType = TStorageOpenArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(StorageOpenArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move(aRhs));
    mType = TStorageOpenArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const StorageDeleteArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(aRhs);
    mType = TStorageDeleteArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(StorageDeleteArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move(aRhs));
    mType = TStorageDeleteArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const StorageKeysArgs& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(aRhs);
    mType = TStorageKeysArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(StorageKeysArgs&& aRhs) -> CacheOpArgs&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move(aRhs));
    mType = TStorageKeysArgs;
    return (*(this));
}

auto CacheOpArgs::operator=(const CacheOpArgs& aRhs) -> CacheOpArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TCacheMatchArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs((aRhs).get_CacheMatchArgs());
            break;
        }
    case TCacheMatchAllArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs((aRhs).get_CacheMatchAllArgs());
            break;
        }
    case TCachePutAllArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs((aRhs).get_CachePutAllArgs());
            break;
        }
    case TCacheDeleteArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs((aRhs).get_CacheDeleteArgs());
            break;
        }
    case TCacheKeysArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs((aRhs).get_CacheKeysArgs());
            break;
        }
    case TStorageMatchArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs((aRhs).get_StorageMatchArgs());
            break;
        }
    case TStorageHasArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs((aRhs).get_StorageHasArgs());
            break;
        }
    case TStorageOpenArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs((aRhs).get_StorageOpenArgs());
            break;
        }
    case TStorageDeleteArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs((aRhs).get_StorageDeleteArgs());
            break;
        }
    case TStorageKeysArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs((aRhs).get_StorageKeysArgs());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto CacheOpArgs::operator=(CacheOpArgs&& aRhs) -> CacheOpArgs&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TCacheMatchArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move((aRhs).get_CacheMatchArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheMatchAllArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move((aRhs).get_CacheMatchAllArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCachePutAllArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move((aRhs).get_CachePutAllArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheDeleteArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move((aRhs).get_CacheDeleteArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheKeysArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move((aRhs).get_CacheKeysArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageMatchArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move((aRhs).get_StorageMatchArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageHasArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move((aRhs).get_StorageHasArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageOpenArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move((aRhs).get_StorageOpenArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageDeleteArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move((aRhs).get_StorageDeleteArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageKeysArgs:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move((aRhs).get_StorageKeysArgs()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace cache
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TCacheMatchArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheMatchArgs());
            // Sentinel = 'TCacheMatchArgs'
            (aWriter)->WriteSentinel(729679267);
            return;
        }
    case union__::TCacheMatchAllArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheMatchAllArgs());
            // Sentinel = 'TCacheMatchAllArgs'
            (aWriter)->WriteSentinel(1043007164);
            return;
        }
    case union__::TCachePutAllArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CachePutAllArgs());
            // Sentinel = 'TCachePutAllArgs'
            (aWriter)->WriteSentinel(833357320);
            return;
        }
    case union__::TCacheDeleteArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheDeleteArgs());
            // Sentinel = 'TCacheDeleteArgs'
            (aWriter)->WriteSentinel(829228553);
            return;
        }
    case union__::TCacheKeysArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheKeysArgs());
            // Sentinel = 'TCacheKeysArgs'
            (aWriter)->WriteSentinel(641860946);
            return;
        }
    case union__::TStorageMatchArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageMatchArgs());
            // Sentinel = 'TStorageMatchArgs'
            (aWriter)->WriteSentinel(994444964);
            return;
        }
    case union__::TStorageHasArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageHasArgs());
            // Sentinel = 'TStorageHasArgs'
            (aWriter)->WriteSentinel(774637011);
            return;
        }
    case union__::TStorageOpenArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageOpenArgs());
            // Sentinel = 'TStorageOpenArgs'
            (aWriter)->WriteSentinel(887424585);
            return;
        }
    case union__::TStorageDeleteArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageDeleteArgs());
            // Sentinel = 'TStorageDeleteArgs'
            (aWriter)->WriteSentinel(1110837002);
            return;
        }
    case union__::TStorageKeysArgs:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageKeysArgs());
            // Sentinel = 'TStorageKeysArgs'
            (aWriter)->WriteSentinel(889783891);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union CacheOpArgs");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheMatchArgs'
            if ((!((aReader)->ReadSentinel(729679267)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheMatchAllArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchAllArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheMatchAllArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheMatchAllArgs'
            if ((!((aReader)->ReadSentinel(1043007164)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchAllArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCachePutAllArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CachePutAllArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCachePutAllArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCachePutAllArgs'
            if ((!((aReader)->ReadSentinel(833357320)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCachePutAllArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheDeleteArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheDeleteArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheDeleteArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheDeleteArgs'
            if ((!((aReader)->ReadSentinel(829228553)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheDeleteArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheKeysArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheKeysArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheKeysArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheKeysArgs'
            if ((!((aReader)->ReadSentinel(641860946)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheKeysArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageMatchArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageMatchArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageMatchArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageMatchArgs'
            if ((!((aReader)->ReadSentinel(994444964)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageMatchArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageHasArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageHasArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageHasArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageHasArgs'
            if ((!((aReader)->ReadSentinel(774637011)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageHasArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageOpenArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageOpenArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageOpenArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageOpenArgs'
            if ((!((aReader)->ReadSentinel(887424585)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageOpenArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageDeleteArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageDeleteArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageDeleteArgs of union CacheOpArgs");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageDeleteArgs'
            if ((!((aReader)->ReadSentinel(1110837002)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageDeleteArgs of union CacheOpArgs");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageKeysArgs:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageKeysArgs>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageKeysArgs of union CacheOpArgs");
                return {};

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::CacheMatchResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___maybeResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheResponse>>(aReader);
    if (!maybe___maybeResponse) {
        aReader->FatalError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'CacheMatchResult'");
        return {};

    }
    auto& _maybeResponse = *maybe___maybeResponse;
    // Sentinel = 'maybeResponse'
    if ((!((aReader)->ReadSentinel(624690526)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'CacheMatchResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_maybeResponse)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::CacheMatchAllResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___responseList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheResponse>>(aReader);
    if (!maybe___responseList) {
        aReader->FatalError("Error deserializing 'responseList' (CacheResponse[]) member of 'CacheMatchAllResult'");
        return {};

    }
    auto& _responseList = *maybe___responseList;
    // Sentinel = 'responseList'
    if ((!((aReader)->ReadSentinel(554894604)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'responseList' (CacheResponse[]) member of 'CacheMatchAllResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_responseList)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::CachePutAllResult>::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 CacheDeleteResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla

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

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

    }
    auto& _success = *maybe___success;
    // Sentinel = 'success'
    if ((!((aReader)->ReadSentinel(200082170)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'CacheDeleteResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_success)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::CacheKeysResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheRequest>>(aReader);
    if (!maybe___requestList) {
        aReader->FatalError("Error deserializing 'requestList' (CacheRequest[]) member of 'CacheKeysResult'");
        return {};

    }
    auto& _requestList = *maybe___requestList;
    // Sentinel = 'requestList'
    if ((!((aReader)->ReadSentinel(469894310)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestList' (CacheRequest[]) member of 'CacheKeysResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestList)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::cache::StorageMatchResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___maybeResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheResponse>>(aReader);
    if (!maybe___maybeResponse) {
        aReader->FatalError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'StorageMatchResult'");
        return {};

    }
    auto& _maybeResponse = *maybe___maybeResponse;
    // Sentinel = 'maybeResponse'
    if ((!((aReader)->ReadSentinel(624690526)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'StorageMatchResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_maybeResponse)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _success = *maybe___success;
    // Sentinel = 'success'
    if ((!((aReader)->ReadSentinel(200082170)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'StorageHasResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_success)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageOpenResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).actor());
    // Sentinel = 'actor'
    (aWriter)->WriteSentinel(102892058);
    IPC::WriteParam(aWriter, (aVar).ns());
    // Sentinel = 'ns'
    (aWriter)->WriteSentinel(22085858);
}

auto ParamTraits<::mozilla::dom::cache::StorageOpenResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___actor = IPC::ReadParam<::mozilla::ipc::SideVariant<::mozilla::dom::cache::PCacheParent*, ::mozilla::dom::cache::PCacheChild*>>(aReader);
    if (!maybe___actor) {
        aReader->FatalError("Error deserializing 'actor' (PCache) member of 'StorageOpenResult'");
        return {};

    }
    auto& _actor = *maybe___actor;
    // Sentinel = 'actor'
    if ((!((aReader)->ReadSentinel(102892058)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'actor' (PCache) member of 'StorageOpenResult'");
        return {};
    }
    auto maybe___ns = IPC::ReadParam<::mozilla::dom::cache::Namespace>(aReader);
    if (!maybe___ns) {
        aReader->FatalError("Error deserializing 'ns' (Namespace) member of 'StorageOpenResult'");
        return {};

    }
    auto& _ns = *maybe___ns;
    // Sentinel = 'ns'
    if ((!((aReader)->ReadSentinel(22085858)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ns' (Namespace) member of 'StorageOpenResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            _actor,
            std::move(_ns)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _success = *maybe___success;
    // Sentinel = 'success'
    if ((!((aReader)->ReadSentinel(200082170)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'StorageDeleteResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_success)};
    return result__;
}

} // namespace IPC

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

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CacheOpResult|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheOpResult::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tvoid_t:
        {
            (ptr_void_t())->~void_t__tdef();
            break;
        }
    case TCacheMatchResult:
        {
            (ptr_CacheMatchResult())->~CacheMatchResult__tdef();
            break;
        }
    case TCacheMatchAllResult:
        {
            (ptr_CacheMatchAllResult())->~CacheMatchAllResult__tdef();
            break;
        }
    case TCachePutAllResult:
        {
            (ptr_CachePutAllResult())->~CachePutAllResult__tdef();
            break;
        }
    case TCacheDeleteResult:
        {
            (ptr_CacheDeleteResult())->~CacheDeleteResult__tdef();
            break;
        }
    case TCacheKeysResult:
        {
            (ptr_CacheKeysResult())->~CacheKeysResult__tdef();
            break;
        }
    case TStorageMatchResult:
        {
            (ptr_StorageMatchResult())->~StorageMatchResult__tdef();
            break;
        }
    case TStorageHasResult:
        {
            (ptr_StorageHasResult())->~StorageHasResult__tdef();
            break;
        }
    case TStorageOpenResult:
        {
            (ptr_StorageOpenResult())->~StorageOpenResult__tdef();
            break;
        }
    case TStorageDeleteResult:
        {
            (ptr_StorageDeleteResult())->~StorageDeleteResult__tdef();
            break;
        }
    case TStorageKeysResult:
        {
            (ptr_StorageKeysResult())->~StorageKeysResult__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(aOther);
    mType = TCacheMatchResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheMatchResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move(aOther));
    mType = TCacheMatchResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchAllResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(aOther);
    mType = TCacheMatchAllResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheMatchAllResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move(aOther));
    mType = TCacheMatchAllResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CachePutAllResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(aOther);
    mType = TCachePutAllResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CachePutAllResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move(aOther));
    mType = TCachePutAllResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheDeleteResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(aOther);
    mType = TCacheDeleteResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheDeleteResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move(aOther));
    mType = TCacheDeleteResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheKeysResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(aOther);
    mType = TCacheKeysResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheKeysResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move(aOther));
    mType = TCacheKeysResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageMatchResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(aOther);
    mType = TStorageMatchResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageMatchResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move(aOther));
    mType = TStorageMatchResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageHasResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(aOther);
    mType = TStorageHasResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageHasResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move(aOther));
    mType = TStorageHasResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageOpenResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(aOther);
    mType = TStorageOpenResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageOpenResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move(aOther));
    mType = TStorageOpenResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageDeleteResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(aOther);
    mType = TStorageDeleteResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageDeleteResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move(aOther));
    mType = TStorageDeleteResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageKeysResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(aOther);
    mType = TStorageKeysResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageKeysResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move(aOther));
    mType = TStorageKeysResult;
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheOpResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case TCacheMatchResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult((aOther).get_CacheMatchResult());
            break;
        }
    case TCacheMatchAllResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult((aOther).get_CacheMatchAllResult());
            break;
        }
    case TCachePutAllResult:
        {
            new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult((aOther).get_CachePutAllResult());
            break;
        }
    case TCacheDeleteResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult((aOther).get_CacheDeleteResult());
            break;
        }
    case TCacheKeysResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult((aOther).get_CacheKeysResult());
            break;
        }
    case TStorageMatchResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult((aOther).get_StorageMatchResult());
            break;
        }
    case TStorageHasResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult((aOther).get_StorageHasResult());
            break;
        }
    case TStorageOpenResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult((aOther).get_StorageOpenResult());
            break;
        }
    case TStorageDeleteResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult((aOther).get_StorageDeleteResult());
            break;
        }
    case TStorageKeysResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult((aOther).get_StorageKeysResult());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheOpResult&& 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 TCacheMatchResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move((aOther).get_CacheMatchResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheMatchAllResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move((aOther).get_CacheMatchAllResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCachePutAllResult:
        {
            new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move((aOther).get_CachePutAllResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheDeleteResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move((aOther).get_CacheDeleteResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TCacheKeysResult:
        {
            new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move((aOther).get_CacheKeysResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageMatchResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move((aOther).get_StorageMatchResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageHasResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move((aOther).get_StorageHasResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageOpenResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move((aOther).get_StorageOpenResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageDeleteResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move((aOther).get_StorageDeleteResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TStorageKeysResult:
        {
            new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move((aOther).get_StorageKeysResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto CacheOpResult::operator=(const CacheMatchResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(aRhs);
    mType = TCacheMatchResult;
    return (*(this));
}

auto CacheOpResult::operator=(CacheMatchResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move(aRhs));
    mType = TCacheMatchResult;
    return (*(this));
}

auto CacheOpResult::operator=(const CacheMatchAllResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(aRhs);
    mType = TCacheMatchAllResult;
    return (*(this));
}

auto CacheOpResult::operator=(CacheMatchAllResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move(aRhs));
    mType = TCacheMatchAllResult;
    return (*(this));
}

auto CacheOpResult::operator=(const CachePutAllResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(aRhs);
    mType = TCachePutAllResult;
    return (*(this));
}

auto CacheOpResult::operator=(CachePutAllResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move(aRhs));
    mType = TCachePutAllResult;
    return (*(this));
}

auto CacheOpResult::operator=(const CacheDeleteResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(aRhs);
    mType = TCacheDeleteResult;
    return (*(this));
}

auto CacheOpResult::operator=(CacheDeleteResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move(aRhs));
    mType = TCacheDeleteResult;
    return (*(this));
}

auto CacheOpResult::operator=(const CacheKeysResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(aRhs);
    mType = TCacheKeysResult;
    return (*(this));
}

auto CacheOpResult::operator=(CacheKeysResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move(aRhs));
    mType = TCacheKeysResult;
    return (*(this));
}

auto CacheOpResult::operator=(const StorageMatchResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(aRhs);
    mType = TStorageMatchResult;
    return (*(this));
}

auto CacheOpResult::operator=(StorageMatchResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move(aRhs));
    mType = TStorageMatchResult;
    return (*(this));
}

auto CacheOpResult::operator=(const StorageHasResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(aRhs);
    mType = TStorageHasResult;
    return (*(this));
}

auto CacheOpResult::operator=(StorageHasResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move(aRhs));
    mType = TStorageHasResult;
    return (*(this));
}

auto CacheOpResult::operator=(const StorageOpenResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(aRhs);
    mType = TStorageOpenResult;
    return (*(this));
}

auto CacheOpResult::operator=(StorageOpenResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move(aRhs));
    mType = TStorageOpenResult;
    return (*(this));
}

auto CacheOpResult::operator=(const StorageDeleteResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(aRhs);
    mType = TStorageDeleteResult;
    return (*(this));
}

auto CacheOpResult::operator=(StorageDeleteResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move(aRhs));
    mType = TStorageDeleteResult;
    return (*(this));
}

auto CacheOpResult::operator=(const StorageKeysResult& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(aRhs);
    mType = TStorageKeysResult;
    return (*(this));
}

auto CacheOpResult::operator=(StorageKeysResult&& aRhs) -> CacheOpResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move(aRhs));
    mType = TStorageKeysResult;
    return (*(this));
}

auto CacheOpResult::operator=(const CacheOpResult& aRhs) -> CacheOpResult&
{
    (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 TCacheMatchResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult((aRhs).get_CacheMatchResult());
            break;
        }
    case TCacheMatchAllResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult((aRhs).get_CacheMatchAllResult());
            break;
        }
    case TCachePutAllResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult((aRhs).get_CachePutAllResult());
            break;
        }
    case TCacheDeleteResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult((aRhs).get_CacheDeleteResult());
            break;
        }
    case TCacheKeysResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult((aRhs).get_CacheKeysResult());
            break;
        }
    case TStorageMatchResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult((aRhs).get_StorageMatchResult());
            break;
        }
    case TStorageHasResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult((aRhs).get_StorageHasResult());
            break;
        }
    case TStorageOpenResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult((aRhs).get_StorageOpenResult());
            break;
        }
    case TStorageDeleteResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult((aRhs).get_StorageDeleteResult());
            break;
        }
    case TStorageKeysResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult((aRhs).get_StorageKeysResult());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto CacheOpResult::operator=(CacheOpResult&& aRhs) -> CacheOpResult&
{
    (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 TCacheMatchResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move((aRhs).get_CacheMatchResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheMatchAllResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move((aRhs).get_CacheMatchAllResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCachePutAllResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move((aRhs).get_CachePutAllResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheDeleteResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move((aRhs).get_CacheDeleteResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TCacheKeysResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move((aRhs).get_CacheKeysResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageMatchResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move((aRhs).get_StorageMatchResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageHasResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move((aRhs).get_StorageHasResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageOpenResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move((aRhs).get_StorageOpenResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageDeleteResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move((aRhs).get_StorageDeleteResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TStorageKeysResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move((aRhs).get_StorageKeysResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace cache
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tvoid_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_void_t());
            // Sentinel = 'Tvoid_t'
            (aWriter)->WriteSentinel(189006554);
            return;
        }
    case union__::TCacheMatchResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheMatchResult());
            // Sentinel = 'TCacheMatchResult'
            (aWriter)->WriteSentinel(946538133);
            return;
        }
    case union__::TCacheMatchAllResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheMatchAllResult());
            // Sentinel = 'TCacheMatchAllResult'
            (aWriter)->WriteSentinel(1296697262);
            return;
        }
    case union__::TCachePutAllResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_CachePutAllResult());
            // Sentinel = 'TCachePutAllResult'
            (aWriter)->WriteSentinel(1063454458);
            return;
        }
    case union__::TCacheDeleteResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheDeleteResult());
            // Sentinel = 'TCacheDeleteResult'
            (aWriter)->WriteSentinel(1059456763);
            return;
        }
    case union__::TCacheKeysResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_CacheKeysResult());
            // Sentinel = 'TCacheKeysResult'
            (aWriter)->WriteSentinel(848102980);
            return;
        }
    case union__::TStorageMatchResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageMatchResult());
            // Sentinel = 'TStorageMatchResult'
            (aWriter)->WriteSentinel(1244989334);
            return;
        }
    case union__::TStorageHasResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageHasResult());
            // Sentinel = 'TStorageHasResult'
            (aWriter)->WriteSentinel(997787333);
            return;
        }
    case union__::TStorageOpenResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageOpenResult());
            // Sentinel = 'TStorageOpenResult'
            (aWriter)->WriteSentinel(1126041403);
            return;
        }
    case union__::TStorageDeleteResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageDeleteResult());
            // Sentinel = 'TStorageDeleteResult'
            (aWriter)->WriteSentinel(1374750716);
            return;
        }
    case union__::TStorageKeysResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_StorageKeysResult());
            // Sentinel = 'TStorageKeysResult'
            (aWriter)->WriteSentinel(1129711429);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union CacheOpResult");
            return;
        }
    }
}

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

    }
    auto& type = *maybe__type;
    // Sentinel = 'CacheOpResult'
    if ((!((aReader)->ReadSentinel(566363411)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union CacheOpResult");
        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 CacheOpResult");
                return {};

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheMatchResult'
            if ((!((aReader)->ReadSentinel(946538133)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheMatchAllResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchAllResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheMatchAllResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheMatchAllResult'
            if ((!((aReader)->ReadSentinel(1296697262)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchAllResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCachePutAllResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CachePutAllResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCachePutAllResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCachePutAllResult'
            if ((!((aReader)->ReadSentinel(1063454458)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCachePutAllResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheDeleteResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheDeleteResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheDeleteResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheDeleteResult'
            if ((!((aReader)->ReadSentinel(1059456763)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheDeleteResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TCacheKeysResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheKeysResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TCacheKeysResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TCacheKeysResult'
            if ((!((aReader)->ReadSentinel(848102980)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TCacheKeysResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageMatchResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageMatchResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageMatchResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageMatchResult'
            if ((!((aReader)->ReadSentinel(1244989334)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageMatchResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageHasResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageHasResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageHasResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageHasResult'
            if ((!((aReader)->ReadSentinel(997787333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageHasResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageOpenResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageOpenResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageOpenResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageOpenResult'
            if ((!((aReader)->ReadSentinel(1126041403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageOpenResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageDeleteResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageDeleteResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageDeleteResult of union CacheOpResult");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TStorageDeleteResult'
            if ((!((aReader)->ReadSentinel(1374750716)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TStorageDeleteResult of union CacheOpResult");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TStorageKeysResult:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageKeysResult>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TStorageKeysResult of union CacheOpResult");
                return {};

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

} // namespace IPC
