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


#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileChild.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.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 SerializedKeyRange|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedKeyRange>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).lower());
    // Sentinel = 'lower'
    (aWriter)->WriteSentinel(108921386);
    IPC::WriteParam(aWriter, (aVar).upper());
    // Sentinel = 'upper'
    (aWriter)->WriteSentinel(110756397);
    IPC::WriteParam(aWriter, (aVar).lowerOpen());
    // Sentinel = 'lowerOpen'
    (aWriter)->WriteSentinel(317326268);
    IPC::WriteParam(aWriter, (aVar).upperOpen());
    // Sentinel = 'upperOpen'
    (aWriter)->WriteSentinel(319947711);
    IPC::WriteParam(aWriter, (aVar).isOnly());
    // Sentinel = 'isOnly'
    (aWriter)->WriteSentinel(143786623);
}

auto ParamTraits<::mozilla::dom::indexedDB::SerializedKeyRange>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___lower = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
    if (!maybe___lower) {
        aReader->FatalError("Error deserializing 'lower' (Key) member of 'SerializedKeyRange'");
        return {};

    }
    auto& _lower = *maybe___lower;
    // Sentinel = 'lower'
    if ((!((aReader)->ReadSentinel(108921386)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lower' (Key) member of 'SerializedKeyRange'");
        return {};
    }
    auto maybe___upper = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
    if (!maybe___upper) {
        aReader->FatalError("Error deserializing 'upper' (Key) member of 'SerializedKeyRange'");
        return {};

    }
    auto& _upper = *maybe___upper;
    // Sentinel = 'upper'
    if ((!((aReader)->ReadSentinel(110756397)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'upper' (Key) member of 'SerializedKeyRange'");
        return {};
    }
    auto maybe___lowerOpen = IPC::ReadParam<bool>(aReader);
    if (!maybe___lowerOpen) {
        aReader->FatalError("Error deserializing 'lowerOpen' (bool) member of 'SerializedKeyRange'");
        return {};

    }
    auto& _lowerOpen = *maybe___lowerOpen;
    // Sentinel = 'lowerOpen'
    if ((!((aReader)->ReadSentinel(317326268)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lowerOpen' (bool) member of 'SerializedKeyRange'");
        return {};
    }
    auto maybe___upperOpen = IPC::ReadParam<bool>(aReader);
    if (!maybe___upperOpen) {
        aReader->FatalError("Error deserializing 'upperOpen' (bool) member of 'SerializedKeyRange'");
        return {};

    }
    auto& _upperOpen = *maybe___upperOpen;
    // Sentinel = 'upperOpen'
    if ((!((aReader)->ReadSentinel(319947711)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'upperOpen' (bool) member of 'SerializedKeyRange'");
        return {};
    }
    auto maybe___isOnly = IPC::ReadParam<bool>(aReader);
    if (!maybe___isOnly) {
        aReader->FatalError("Error deserializing 'isOnly' (bool) member of 'SerializedKeyRange'");
        return {};

    }
    auto& _isOnly = *maybe___isOnly;
    // Sentinel = 'isOnly'
    if ((!((aReader)->ReadSentinel(143786623)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isOnly' (bool) member of 'SerializedKeyRange'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_lower),
            std::move(_upper),
            std::move(_lowerOpen),
            std::move(_upperOpen),
            std::move(_isOnly)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union NullableBlob|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto NullableBlob::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    case TIPCBlob:
        {
            (ptr_IPCBlob())->~IPCBlob__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT NullableBlob::NullableBlob(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT NullableBlob::NullableBlob(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT NullableBlob::NullableBlob(const IPCBlob& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(aOther);
    mType = TIPCBlob;
}

MOZ_IMPLICIT NullableBlob::NullableBlob(IPCBlob&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move(aOther));
    mType = TIPCBlob;
}

MOZ_IMPLICIT NullableBlob::NullableBlob(const NullableBlob& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case TIPCBlob:
        {
            new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob((aOther).get_IPCBlob());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT NullableBlob::NullableBlob(NullableBlob&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCBlob:
        {
            new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move((aOther).get_IPCBlob()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto NullableBlob::operator=(const null_t& aRhs) -> NullableBlob&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto NullableBlob::operator=(null_t&& aRhs) -> NullableBlob&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aRhs));
    mType = Tnull_t;
    return (*(this));
}

auto NullableBlob::operator=(const IPCBlob& aRhs) -> NullableBlob&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(aRhs);
    mType = TIPCBlob;
    return (*(this));
}

auto NullableBlob::operator=(IPCBlob&& aRhs) -> NullableBlob&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move(aRhs));
    mType = TIPCBlob;
    return (*(this));
}

auto NullableBlob::operator=(const NullableBlob& aRhs) -> NullableBlob&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
            break;
        }
    case TIPCBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob((aRhs).get_IPCBlob());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto NullableBlob::operator=(NullableBlob&& aRhs) -> NullableBlob&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnull_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move((aRhs).get_IPCBlob()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnull_t:
        {
            IPC::WriteParam(aWriter, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aWriter)->WriteSentinel(190186211);
            return;
        }
    case union__::TIPCBlob:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCBlob());
            // Sentinel = 'TIPCBlob'
            (aWriter)->WriteSentinel(190972592);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union NullableBlob");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).file());
    // Sentinel = 'file'
    (aWriter)->WriteSentinel(68420001);
    IPC::WriteParam(aWriter, (aVar).type());
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
}

auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___file = IPC::ReadParam<::mozilla::dom::indexedDB::NullableBlob>(aReader);
    if (!maybe___file) {
        aReader->FatalError("Error deserializing 'file' (NullableBlob) member of 'SerializedStructuredCloneFile'");
        return {};

    }
    auto& _file = *maybe___file;
    // Sentinel = 'file'
    if ((!((aReader)->ReadSentinel(68420001)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'file' (NullableBlob) member of 'SerializedStructuredCloneFile'");
        return {};
    }
    auto maybe___type = IPC::ReadParam<::mozilla::dom::indexedDB::StructuredCloneFileBase::FileType>(aReader);
    if (!maybe___type) {
        aReader->FatalError("Error deserializing 'type' (FileType) member of 'SerializedStructuredCloneFile'");
        return {};

    }
    auto& _type = *maybe___type;
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (FileType) member of 'SerializedStructuredCloneFile'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_file),
            std::move(_type)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    IPC::WriteParam(aWriter, (aVar).files());
    // Sentinel = 'files'
    (aWriter)->WriteSentinel(103285268);
    IPC::WriteParam(aWriter, (aVar).hasPreprocessInfo());
    // Sentinel = 'hasPreprocessInfo'
    (aWriter)->WriteSentinel(1045169903);
}

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

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

    }
    auto& _files = *maybe___files;
    // Sentinel = 'files'
    if ((!((aReader)->ReadSentinel(103285268)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'SerializedStructuredCloneReadInfo'");
        return {};
    }
    auto maybe___hasPreprocessInfo = IPC::ReadParam<bool>(aReader);
    if (!maybe___hasPreprocessInfo) {
        aReader->FatalError("Error deserializing 'hasPreprocessInfo' (bool) member of 'SerializedStructuredCloneReadInfo'");
        return {};

    }
    auto& _hasPreprocessInfo = *maybe___hasPreprocessInfo;
    // Sentinel = 'hasPreprocessInfo'
    if ((!((aReader)->ReadSentinel(1045169903)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasPreprocessInfo' (bool) member of 'SerializedStructuredCloneReadInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_data),
            std::move(_files),
            std::move(_hasPreprocessInfo)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    (aWriter)->WriteBytes((&((aVar).offsetToKeyProp())), 8);
    // Sentinel = 'offsetToKeyProp'
    (aWriter)->WriteSentinel(816645653);
}

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexUpdateInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
    IPC::WriteParam(aWriter, (aVar).localizedValue());
    // Sentinel = 'localizedValue'
    (aWriter)->WriteSentinel(721487285);
    (aWriter)->WriteBytes((&((aVar).indexId())), 8);
    // Sentinel = 'indexId'
    (aWriter)->WriteSentinel(190841542);
}

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

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (Key) member of 'IndexUpdateInfo'");
        return {};
    }
    auto maybe___localizedValue = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
    if (!maybe___localizedValue) {
        aReader->FatalError("Error deserializing 'localizedValue' (Key) member of 'IndexUpdateInfo'");
        return {};

    }
    auto& _localizedValue = *maybe___localizedValue;
    // Sentinel = 'localizedValue'
    if ((!((aReader)->ReadSentinel(721487285)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'localizedValue' (Key) member of 'IndexUpdateInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_value),
            std::move(_localizedValue)};
    if ((!((aReader)->ReadBytesInto((&((result__)->indexId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'indexId'
    if ((!((aReader)->ReadSentinel(190841542)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).persistenceType());
    // Sentinel = 'persistenceType'
    (aWriter)->WriteSentinel(853345864);
    (aWriter)->WriteBytes((&((aVar).version())), 8);
    // Sentinel = 'version'
    (aWriter)->WriteSentinel(204210951);
}

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

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

    }
    auto& _persistenceType = *maybe___persistenceType;
    // Sentinel = 'persistenceType'
    if ((!((aReader)->ReadSentinel(853345864)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'DatabaseMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_name),
            ::uint64_t{0},
            std::move(_persistenceType)};
    if ((!((aReader)->ReadBytesInto((&((result__)->version())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'version'
    if ((!((aReader)->ReadSentinel(204210951)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).keyPath());
    // Sentinel = 'keyPath'
    (aWriter)->WriteSentinel(190972631);
    IPC::WriteParam(aWriter, (aVar).autoIncrement());
    // Sentinel = 'autoIncrement'
    (aWriter)->WriteSentinel(626394463);
    (aWriter)->WriteBytes((&((aVar).id())), 8);
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
}

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

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

    }
    auto& _keyPath = *maybe___keyPath;
    // Sentinel = 'keyPath'
    if ((!((aReader)->ReadSentinel(190972631)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyPath' (KeyPath) member of 'ObjectStoreMetadata'");
        return {};
    }
    auto maybe___autoIncrement = IPC::ReadParam<bool>(aReader);
    if (!maybe___autoIncrement) {
        aReader->FatalError("Error deserializing 'autoIncrement' (bool) member of 'ObjectStoreMetadata'");
        return {};

    }
    auto& _autoIncrement = *maybe___autoIncrement;
    // Sentinel = 'autoIncrement'
    if ((!((aReader)->ReadSentinel(626394463)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'autoIncrement' (bool) member of 'ObjectStoreMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_name),
            std::move(_keyPath),
            std::move(_autoIncrement)};
    if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).keyPath());
    // Sentinel = 'keyPath'
    (aWriter)->WriteSentinel(190972631);
    IPC::WriteParam(aWriter, (aVar).locale());
    // Sentinel = 'locale'
    (aWriter)->WriteSentinel(145031793);
    IPC::WriteParam(aWriter, (aVar).unique());
    // Sentinel = 'unique'
    (aWriter)->WriteSentinel(154141336);
    IPC::WriteParam(aWriter, (aVar).multiEntry());
    // Sentinel = 'multiEntry'
    (aWriter)->WriteSentinel(389350462);
    IPC::WriteParam(aWriter, (aVar).autoLocale());
    // Sentinel = 'autoLocale'
    (aWriter)->WriteSentinel(377029642);
    (aWriter)->WriteBytes((&((aVar).id())), 8);
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
}

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

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

    }
    auto& _keyPath = *maybe___keyPath;
    // Sentinel = 'keyPath'
    if ((!((aReader)->ReadSentinel(190972631)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyPath' (KeyPath) member of 'IndexMetadata'");
        return {};
    }
    auto maybe___locale = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___locale) {
        aReader->FatalError("Error deserializing 'locale' (nsCString) member of 'IndexMetadata'");
        return {};

    }
    auto& _locale = *maybe___locale;
    // Sentinel = 'locale'
    if ((!((aReader)->ReadSentinel(145031793)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'locale' (nsCString) member of 'IndexMetadata'");
        return {};
    }
    auto maybe___unique = IPC::ReadParam<bool>(aReader);
    if (!maybe___unique) {
        aReader->FatalError("Error deserializing 'unique' (bool) member of 'IndexMetadata'");
        return {};

    }
    auto& _unique = *maybe___unique;
    // Sentinel = 'unique'
    if ((!((aReader)->ReadSentinel(154141336)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'unique' (bool) member of 'IndexMetadata'");
        return {};
    }
    auto maybe___multiEntry = IPC::ReadParam<bool>(aReader);
    if (!maybe___multiEntry) {
        aReader->FatalError("Error deserializing 'multiEntry' (bool) member of 'IndexMetadata'");
        return {};

    }
    auto& _multiEntry = *maybe___multiEntry;
    // Sentinel = 'multiEntry'
    if ((!((aReader)->ReadSentinel(389350462)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'multiEntry' (bool) member of 'IndexMetadata'");
        return {};
    }
    auto maybe___autoLocale = IPC::ReadParam<bool>(aReader);
    if (!maybe___autoLocale) {
        aReader->FatalError("Error deserializing 'autoLocale' (bool) member of 'IndexMetadata'");
        return {};

    }
    auto& _autoLocale = *maybe___autoLocale;
    // Sentinel = 'autoLocale'
    if ((!((aReader)->ReadSentinel(377029642)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'autoLocale' (bool) member of 'IndexMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_name),
            std::move(_keyPath),
            std::move(_locale),
            std::move(_unique),
            std::move(_multiEntry),
            std::move(_autoLocale)};
    if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseSpec>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).metadata());
    // Sentinel = 'metadata'
    (aWriter)->WriteSentinel(248251202);
    IPC::WriteParam(aWriter, (aVar).objectStores());
    // Sentinel = 'objectStores'
    (aWriter)->WriteSentinel(535823608);
}

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

    }
    auto& _metadata = *maybe___metadata;
    // Sentinel = 'metadata'
    if ((!((aReader)->ReadSentinel(248251202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (DatabaseMetadata) member of 'DatabaseSpec'");
        return {};
    }
    auto maybe___objectStores = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::ObjectStoreSpec>>(aReader);
    if (!maybe___objectStores) {
        aReader->FatalError("Error deserializing 'objectStores' (ObjectStoreSpec[]) member of 'DatabaseSpec'");
        return {};

    }
    auto& _objectStores = *maybe___objectStores;
    // Sentinel = 'objectStores'
    if ((!((aReader)->ReadSentinel(535823608)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'objectStores' (ObjectStoreSpec[]) member of 'DatabaseSpec'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_metadata),
            std::move(_objectStores)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreSpec>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).metadata());
    // Sentinel = 'metadata'
    (aWriter)->WriteSentinel(248251202);
    IPC::WriteParam(aWriter, (aVar).indexes());
    // Sentinel = 'indexes'
    (aWriter)->WriteSentinel(195494641);
}

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

    }
    auto& _metadata = *maybe___metadata;
    // Sentinel = 'metadata'
    if ((!((aReader)->ReadSentinel(248251202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (ObjectStoreMetadata) member of 'ObjectStoreSpec'");
        return {};
    }
    auto maybe___indexes = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::IndexMetadata>>(aReader);
    if (!maybe___indexes) {
        aReader->FatalError("Error deserializing 'indexes' (IndexMetadata[]) member of 'ObjectStoreSpec'");
        return {};

    }
    auto& _indexes = *maybe___indexes;
    // Sentinel = 'indexes'
    if ((!((aReader)->ReadSentinel(195494641)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'indexes' (IndexMetadata[]) member of 'ObjectStoreSpec'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_metadata),
            std::move(_indexes)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::CommonOpenCursorParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    IPC::WriteParam(aWriter, (aVar).direction());
    // Sentinel = 'direction'
    (aWriter)->WriteSentinel(311886786);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::CommonOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'CommonOpenCursorParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'CommonOpenCursorParams'");
        return {};
    }
    auto maybe___direction = IPC::ReadParam<::mozilla::dom::IDBCursor::Direction>(aReader);
    if (!maybe___direction) {
        aReader->FatalError("Error deserializing 'direction' (Direction) member of 'CommonOpenCursorParams'");
        return {};

    }
    auto& _direction = *maybe___direction;
    // Sentinel = 'direction'
    if ((!((aReader)->ReadSentinel(311886786)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'direction' (Direction) member of 'CommonOpenCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_optionalKeyRange),
            std::move(_direction)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
    if (!maybe___commonParams) {
        aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenCursorParams'");
        return {};

    }
    auto& _commonParams = *maybe___commonParams;
    // Sentinel = 'commonParams'
    if ((!((aReader)->ReadSentinel(537068782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonParams)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
    if (!maybe___commonParams) {
        aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenKeyCursorParams'");
        return {};

    }
    auto& _commonParams = *maybe___commonParams;
    // Sentinel = 'commonParams'
    if ((!((aReader)->ReadSentinel(537068782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenKeyCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonParams)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).commonParams());
    // Sentinel = 'commonParams'
    (aWriter)->WriteSentinel(537068782);
    (aWriter)->WriteBytes((&((aVar).indexId())), 8);
    // Sentinel = 'indexId'
    (aWriter)->WriteSentinel(190841542);
}

auto ParamTraits<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
    if (!maybe___commonParams) {
        aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'CommonIndexOpenCursorParams'");
        return {};

    }
    auto& _commonParams = *maybe___commonParams;
    // Sentinel = 'commonParams'
    if ((!((aReader)->ReadSentinel(537068782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'CommonIndexOpenCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonParams),
            ::int64_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->indexId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'indexId'
    if ((!((aReader)->ReadSentinel(190841542)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonIndexParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>(aReader);
    if (!maybe___commonIndexParams) {
        aReader->FatalError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenCursorParams'");
        return {};

    }
    auto& _commonIndexParams = *maybe___commonIndexParams;
    // Sentinel = 'commonIndexParams'
    if ((!((aReader)->ReadSentinel(1041762022)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonIndexParams)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenKeyCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonIndexParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>(aReader);
    if (!maybe___commonIndexParams) {
        aReader->FatalError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenKeyCursorParams'");
        return {};

    }
    auto& _commonIndexParams = *maybe___commonIndexParams;
    // Sentinel = 'commonIndexParams'
    if ((!((aReader)->ReadSentinel(1041762022)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenKeyCursorParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonIndexParams)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto OpenCursorParams::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TObjectStoreOpenCursorParams:
        {
            (ptr_ObjectStoreOpenCursorParams())->~ObjectStoreOpenCursorParams__tdef();
            break;
        }
    case TObjectStoreOpenKeyCursorParams:
        {
            (ptr_ObjectStoreOpenKeyCursorParams())->~ObjectStoreOpenKeyCursorParams__tdef();
            break;
        }
    case TIndexOpenCursorParams:
        {
            (ptr_IndexOpenCursorParams())->~IndexOpenCursorParams__tdef();
            break;
        }
    case TIndexOpenKeyCursorParams:
        {
            (ptr_IndexOpenKeyCursorParams())->~IndexOpenKeyCursorParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenCursorParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(aOther);
    mType = TObjectStoreOpenCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(ObjectStoreOpenCursorParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move(aOther));
    mType = TObjectStoreOpenCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenKeyCursorParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(aOther);
    mType = TObjectStoreOpenKeyCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(ObjectStoreOpenKeyCursorParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move(aOther));
    mType = TObjectStoreOpenKeyCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenCursorParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(aOther);
    mType = TIndexOpenCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(IndexOpenCursorParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move(aOther));
    mType = TIndexOpenCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenKeyCursorParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(aOther);
    mType = TIndexOpenKeyCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(IndexOpenKeyCursorParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move(aOther));
    mType = TIndexOpenKeyCursorParams;
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const OpenCursorParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TObjectStoreOpenCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams((aOther).get_ObjectStoreOpenCursorParams());
            break;
        }
    case TObjectStoreOpenKeyCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams((aOther).get_ObjectStoreOpenKeyCursorParams());
            break;
        }
    case TIndexOpenCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams((aOther).get_IndexOpenCursorParams());
            break;
        }
    case TIndexOpenKeyCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams((aOther).get_IndexOpenKeyCursorParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(OpenCursorParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TObjectStoreOpenCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move((aOther).get_ObjectStoreOpenCursorParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreOpenKeyCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move((aOther).get_ObjectStoreOpenKeyCursorParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexOpenCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move((aOther).get_IndexOpenCursorParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexOpenKeyCursorParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move((aOther).get_IndexOpenKeyCursorParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto OpenCursorParams::operator=(const ObjectStoreOpenCursorParams& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(aRhs);
    mType = TObjectStoreOpenCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(ObjectStoreOpenCursorParams&& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move(aRhs));
    mType = TObjectStoreOpenCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(const ObjectStoreOpenKeyCursorParams& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(aRhs);
    mType = TObjectStoreOpenKeyCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(ObjectStoreOpenKeyCursorParams&& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move(aRhs));
    mType = TObjectStoreOpenKeyCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(const IndexOpenCursorParams& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(aRhs);
    mType = TIndexOpenCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(IndexOpenCursorParams&& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move(aRhs));
    mType = TIndexOpenCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(const IndexOpenKeyCursorParams& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(aRhs);
    mType = TIndexOpenKeyCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(IndexOpenKeyCursorParams&& aRhs) -> OpenCursorParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move(aRhs));
    mType = TIndexOpenKeyCursorParams;
    return (*(this));
}

auto OpenCursorParams::operator=(const OpenCursorParams& aRhs) -> OpenCursorParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreOpenCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams((aRhs).get_ObjectStoreOpenCursorParams());
            break;
        }
    case TObjectStoreOpenKeyCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams((aRhs).get_ObjectStoreOpenKeyCursorParams());
            break;
        }
    case TIndexOpenCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams((aRhs).get_IndexOpenCursorParams());
            break;
        }
    case TIndexOpenKeyCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams((aRhs).get_IndexOpenKeyCursorParams());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OpenCursorParams::operator=(OpenCursorParams&& aRhs) -> OpenCursorParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreOpenCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move((aRhs).get_ObjectStoreOpenCursorParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreOpenKeyCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move((aRhs).get_ObjectStoreOpenKeyCursorParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexOpenCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move((aRhs).get_IndexOpenCursorParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexOpenKeyCursorParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move((aRhs).get_IndexOpenKeyCursorParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TObjectStoreOpenCursorParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreOpenCursorParams());
            // Sentinel = 'TObjectStoreOpenCursorParams'
            (aWriter)->WriteSentinel(2666662701);
            return;
        }
    case union__::TObjectStoreOpenKeyCursorParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreOpenKeyCursorParams());
            // Sentinel = 'TObjectStoreOpenKeyCursorParams'
            (aWriter)->WriteSentinel(3252882518);
            return;
        }
    case union__::TIndexOpenCursorParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexOpenCursorParams());
            // Sentinel = 'TIndexOpenCursorParams'
            (aWriter)->WriteSentinel(1647970497);
            return;
        }
    case union__::TIndexOpenKeyCursorParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexOpenKeyCursorParams());
            // Sentinel = 'TIndexOpenKeyCursorParams'
            (aWriter)->WriteSentinel(2112293354);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union OpenCursorParams");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreOpenCursorParams'
            if ((!((aReader)->ReadSentinel(2666662701)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreOpenCursorParams of union OpenCursorParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreOpenKeyCursorParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreOpenKeyCursorParams of union OpenCursorParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreOpenKeyCursorParams'
            if ((!((aReader)->ReadSentinel(3252882518)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreOpenKeyCursorParams of union OpenCursorParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexOpenCursorParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexOpenCursorParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexOpenCursorParams of union OpenCursorParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIndexOpenCursorParams'
            if ((!((aReader)->ReadSentinel(1647970497)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexOpenCursorParams of union OpenCursorParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexOpenKeyCursorParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexOpenKeyCursorParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexOpenKeyCursorParams of union OpenCursorParams");
                return {};

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::FileAddInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).file());
    // Sentinel = 'file'
    (aWriter)->WriteSentinel(68420001);
    IPC::WriteParam(aWriter, (aVar).type());
    // Sentinel = 'type'
    (aWriter)->WriteSentinel(75760067);
}

auto ParamTraits<::mozilla::dom::indexedDB::FileAddInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___file = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::dom::indexedDB::PBackgroundIDBDatabaseFileParent*, ::mozilla::dom::indexedDB::PBackgroundIDBDatabaseFileChild*>>>(aReader);
    if (!maybe___file) {
        aReader->FatalError("Error deserializing 'file' (NotNull<PBackgroundIDBDatabaseFile>) member of 'FileAddInfo'");
        return {};

    }
    auto& _file = *maybe___file;
    // Sentinel = 'file'
    if ((!((aReader)->ReadSentinel(68420001)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'file' (NotNull<PBackgroundIDBDatabaseFile>) member of 'FileAddInfo'");
        return {};
    }
    auto maybe___type = IPC::ReadParam<::mozilla::dom::indexedDB::StructuredCloneFileBase::FileType>(aReader);
    if (!maybe___type) {
        aReader->FatalError("Error deserializing 'type' (FileType) member of 'FileAddInfo'");
        return {};

    }
    auto& _type = *maybe___type;
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (FileType) member of 'FileAddInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_file),
            std::move(_type)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).cloneInfo());
    // Sentinel = 'cloneInfo'
    (aWriter)->WriteSentinel(304284574);
    IPC::WriteParam(aWriter, (aVar).key());
    // Sentinel = 'key'
    (aWriter)->WriteSentinel(42402122);
    IPC::WriteParam(aWriter, (aVar).indexUpdateInfos());
    // Sentinel = 'indexUpdateInfos'
    (aWriter)->WriteSentinel(923797115);
    IPC::WriteParam(aWriter, (aVar).fileAddInfos());
    // Sentinel = 'fileAddInfos'
    (aWriter)->WriteSentinel(501220521);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___cloneInfo = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo>(aReader);
    if (!maybe___cloneInfo) {
        aReader->FatalError("Error deserializing 'cloneInfo' (SerializedStructuredCloneWriteInfo) member of 'ObjectStoreAddPutParams'");
        return {};

    }
    auto& _cloneInfo = *maybe___cloneInfo;
    // Sentinel = 'cloneInfo'
    if ((!((aReader)->ReadSentinel(304284574)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfo' (SerializedStructuredCloneWriteInfo) member of 'ObjectStoreAddPutParams'");
        return {};
    }
    auto maybe___key = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
    if (!maybe___key) {
        aReader->FatalError("Error deserializing 'key' (Key) member of 'ObjectStoreAddPutParams'");
        return {};

    }
    auto& _key = *maybe___key;
    // Sentinel = 'key'
    if ((!((aReader)->ReadSentinel(42402122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'key' (Key) member of 'ObjectStoreAddPutParams'");
        return {};
    }
    auto maybe___indexUpdateInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::IndexUpdateInfo>>(aReader);
    if (!maybe___indexUpdateInfos) {
        aReader->FatalError("Error deserializing 'indexUpdateInfos' (IndexUpdateInfo[]) member of 'ObjectStoreAddPutParams'");
        return {};

    }
    auto& _indexUpdateInfos = *maybe___indexUpdateInfos;
    // Sentinel = 'indexUpdateInfos'
    if ((!((aReader)->ReadSentinel(923797115)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'indexUpdateInfos' (IndexUpdateInfo[]) member of 'ObjectStoreAddPutParams'");
        return {};
    }
    auto maybe___fileAddInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::FileAddInfo>>(aReader);
    if (!maybe___fileAddInfos) {
        aReader->FatalError("Error deserializing 'fileAddInfos' (FileAddInfo[]) member of 'ObjectStoreAddPutParams'");
        return {};

    }
    auto& _fileAddInfos = *maybe___fileAddInfos;
    // Sentinel = 'fileAddInfos'
    if ((!((aReader)->ReadSentinel(501220521)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fileAddInfos' (FileAddInfo[]) member of 'ObjectStoreAddPutParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_cloneInfo),
            std::move(_key),
            std::move(_indexUpdateInfos),
            std::move(_fileAddInfos)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>(aReader);
    if (!maybe___commonParams) {
        aReader->FatalError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStoreAddParams'");
        return {};

    }
    auto& _commonParams = *maybe___commonParams;
    // Sentinel = 'commonParams'
    if ((!((aReader)->ReadSentinel(537068782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStoreAddParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonParams)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStorePutParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>(aReader);
    if (!maybe___commonParams) {
        aReader->FatalError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStorePutParams'");
        return {};

    }
    auto& _commonParams = *maybe___commonParams;
    // Sentinel = 'commonParams'
    if ((!((aReader)->ReadSentinel(537068782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStorePutParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_commonParams)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keyRange());
    // Sentinel = 'keyRange'
    (aWriter)->WriteSentinel(244581175);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
    if (!maybe___keyRange) {
        aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetParams'");
        return {};

    }
    auto& _keyRange = *maybe___keyRange;
    // Sentinel = 'keyRange'
    if ((!((aReader)->ReadSentinel(244581175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_keyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keyRange());
    // Sentinel = 'keyRange'
    (aWriter)->WriteSentinel(244581175);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
    if (!maybe___keyRange) {
        aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetKeyParams'");
        return {};

    }
    auto& _keyRange = *maybe___keyRange;
    // Sentinel = 'keyRange'
    if ((!((aReader)->ReadSentinel(244581175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetKeyParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_keyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
    (aWriter)->WriteBytes((&((aVar).limit())), 4);
    // Sentinel = 'limit'
    (aWriter)->WriteSentinel(106037792);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_optionalKeyRange),
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'limit'
    if ((!((aReader)->ReadSentinel(106037792)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
    (aWriter)->WriteBytes((&((aVar).limit())), 4);
    // Sentinel = 'limit'
    (aWriter)->WriteSentinel(106037792);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllKeysParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllKeysParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_optionalKeyRange),
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'limit'
    if ((!((aReader)->ReadSentinel(106037792)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keyRange());
    // Sentinel = 'keyRange'
    (aWriter)->WriteSentinel(244581175);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
    if (!maybe___keyRange) {
        aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreDeleteParams'");
        return {};

    }
    auto& _keyRange = *maybe___keyRange;
    // Sentinel = 'keyRange'
    if ((!((aReader)->ReadSentinel(244581175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreDeleteParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_keyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreClearParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreCountParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
    // Sentinel = 'objectStoreId'
    (aWriter)->WriteSentinel(620234034);
}

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreCountParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreCountParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreCountParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            std::move(_optionalKeyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId'
    if ((!((aReader)->ReadSentinel(620234034)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IndexGetParams, indexId_) - offsetof(IndexGetParams, objectStoreId_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keyRange());
    // Sentinel = 'keyRange'
    (aWriter)->WriteSentinel(244581175);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
    // Sentinel = 'objectStoreId | indexId'
    (aWriter)->WriteSentinel(1793132723);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
    if (!maybe___keyRange) {
        aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetParams'");
        return {};

    }
    auto& _keyRange = *maybe___keyRange;
    // Sentinel = 'keyRange'
    if ((!((aReader)->ReadSentinel(244581175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            ::int64_t{0},
            std::move(_keyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId | indexId'
    if ((!((aReader)->ReadSentinel(1793132723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetKeyParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetKeyParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IndexGetKeyParams, indexId_) - offsetof(IndexGetKeyParams, objectStoreId_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetKeyParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keyRange());
    // Sentinel = 'keyRange'
    (aWriter)->WriteSentinel(244581175);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
    // Sentinel = 'objectStoreId | indexId'
    (aWriter)->WriteSentinel(1793132723);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetKeyParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
    if (!maybe___keyRange) {
        aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetKeyParams'");
        return {};

    }
    auto& _keyRange = *maybe___keyRange;
    // Sentinel = 'keyRange'
    if ((!((aReader)->ReadSentinel(244581175)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetKeyParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            ::int64_t{0},
            std::move(_keyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId | indexId'
    if ((!((aReader)->ReadSentinel(1793132723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetAllParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetAllParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IndexGetAllParams, indexId_) - offsetof(IndexGetAllParams, objectStoreId_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
    // Sentinel = 'objectStoreId | indexId'
    (aWriter)->WriteSentinel(1793132723);
    (aWriter)->WriteBytes((&((aVar).limit())), 4);
    // Sentinel = 'limit'
    (aWriter)->WriteSentinel(106037792);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            ::int64_t{0},
            std::move(_optionalKeyRange),
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId | indexId'
    if ((!((aReader)->ReadSentinel(1793132723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'limit'
    if ((!((aReader)->ReadSentinel(106037792)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetAllKeysParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetAllKeysParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IndexGetAllKeysParams, indexId_) - offsetof(IndexGetAllKeysParams, objectStoreId_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllKeysParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
    // Sentinel = 'objectStoreId | indexId'
    (aWriter)->WriteSentinel(1793132723);
    (aWriter)->WriteBytes((&((aVar).limit())), 4);
    // Sentinel = 'limit'
    (aWriter)->WriteSentinel(106037792);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllKeysParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllKeysParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllKeysParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            ::int64_t{0},
            std::move(_optionalKeyRange),
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId | indexId'
    if ((!((aReader)->ReadSentinel(1793132723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'limit'
    if ((!((aReader)->ReadSentinel(106037792)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexCountParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexCountParams::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IndexCountParams, indexId_) - offsetof(IndexCountParams, objectStoreId_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexCountParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
    // Sentinel = 'optionalKeyRange'
    (aWriter)->WriteSentinel(944572029);
    (aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
    // Sentinel = 'objectStoreId | indexId'
    (aWriter)->WriteSentinel(1793132723);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexCountParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
    if (!maybe___optionalKeyRange) {
        aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexCountParams'");
        return {};

    }
    auto& _optionalKeyRange = *maybe___optionalKeyRange;
    // Sentinel = 'optionalKeyRange'
    if ((!((aReader)->ReadSentinel(944572029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexCountParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::int64_t{0},
            ::int64_t{0},
            std::move(_optionalKeyRange)};
    if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'objectStoreId | indexId'
    if ((!((aReader)->ReadSentinel(1793132723)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto RequestParams::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TObjectStoreAddParams:
        {
            (ptr_ObjectStoreAddParams())->~ObjectStoreAddParams__tdef();
            break;
        }
    case TObjectStorePutParams:
        {
            (ptr_ObjectStorePutParams())->~ObjectStorePutParams__tdef();
            break;
        }
    case TObjectStoreGetParams:
        {
            (ptr_ObjectStoreGetParams())->~ObjectStoreGetParams__tdef();
            break;
        }
    case TObjectStoreGetKeyParams:
        {
            (ptr_ObjectStoreGetKeyParams())->~ObjectStoreGetKeyParams__tdef();
            break;
        }
    case TObjectStoreGetAllParams:
        {
            (ptr_ObjectStoreGetAllParams())->~ObjectStoreGetAllParams__tdef();
            break;
        }
    case TObjectStoreGetAllKeysParams:
        {
            (ptr_ObjectStoreGetAllKeysParams())->~ObjectStoreGetAllKeysParams__tdef();
            break;
        }
    case TObjectStoreDeleteParams:
        {
            (ptr_ObjectStoreDeleteParams())->~ObjectStoreDeleteParams__tdef();
            break;
        }
    case TObjectStoreClearParams:
        {
            (ptr_ObjectStoreClearParams())->~ObjectStoreClearParams__tdef();
            break;
        }
    case TObjectStoreCountParams:
        {
            (ptr_ObjectStoreCountParams())->~ObjectStoreCountParams__tdef();
            break;
        }
    case TIndexGetParams:
        {
            (ptr_IndexGetParams())->~IndexGetParams__tdef();
            break;
        }
    case TIndexGetKeyParams:
        {
            (ptr_IndexGetKeyParams())->~IndexGetKeyParams__tdef();
            break;
        }
    case TIndexGetAllParams:
        {
            (ptr_IndexGetAllParams())->~IndexGetAllParams__tdef();
            break;
        }
    case TIndexGetAllKeysParams:
        {
            (ptr_IndexGetAllKeysParams())->~IndexGetAllKeysParams__tdef();
            break;
        }
    case TIndexCountParams:
        {
            (ptr_IndexCountParams())->~IndexCountParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreAddParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move(aOther));
    mType = TObjectStoreAddParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStorePutParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move(aOther));
    mType = TObjectStorePutParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(aOther);
    mType = TObjectStoreGetParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move(aOther));
    mType = TObjectStoreGetParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetKeyParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(aOther);
    mType = TObjectStoreGetKeyParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetKeyParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move(aOther));
    mType = TObjectStoreGetKeyParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(aOther);
    mType = TObjectStoreGetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetAllParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move(aOther));
    mType = TObjectStoreGetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllKeysParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(aOther);
    mType = TObjectStoreGetAllKeysParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetAllKeysParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move(aOther));
    mType = TObjectStoreGetAllKeysParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreDeleteParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(aOther);
    mType = TObjectStoreDeleteParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreDeleteParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move(aOther));
    mType = TObjectStoreDeleteParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreClearParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(aOther);
    mType = TObjectStoreClearParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreClearParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move(aOther));
    mType = TObjectStoreClearParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreCountParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(aOther);
    mType = TObjectStoreCountParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreCountParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move(aOther));
    mType = TObjectStoreCountParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(aOther);
    mType = TIndexGetParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(IndexGetParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move(aOther));
    mType = TIndexGetParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetKeyParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(aOther);
    mType = TIndexGetKeyParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(IndexGetKeyParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move(aOther));
    mType = TIndexGetKeyParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(aOther);
    mType = TIndexGetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(IndexGetAllParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move(aOther));
    mType = TIndexGetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllKeysParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(aOther);
    mType = TIndexGetAllKeysParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(IndexGetAllKeysParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move(aOther));
    mType = TIndexGetAllKeysParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const IndexCountParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(aOther);
    mType = TIndexCountParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(IndexCountParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move(aOther));
    mType = TIndexCountParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(RequestParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TObjectStoreAddParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move((aOther).get_ObjectStoreAddParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStorePutParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move((aOther).get_ObjectStorePutParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move((aOther).get_ObjectStoreGetParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetKeyParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move((aOther).get_ObjectStoreGetKeyParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move((aOther).get_ObjectStoreGetAllParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllKeysParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move((aOther).get_ObjectStoreGetAllKeysParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreDeleteParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move((aOther).get_ObjectStoreDeleteParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreClearParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move((aOther).get_ObjectStoreClearParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreCountParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move((aOther).get_ObjectStoreCountParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move((aOther).get_IndexGetParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetKeyParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move((aOther).get_IndexGetKeyParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetAllParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move((aOther).get_IndexGetAllParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetAllKeysParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move((aOther).get_IndexGetAllKeysParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexCountParams:
        {
            new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move((aOther).get_IndexCountParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto RequestParams::operator=(ObjectStoreAddParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move(aRhs));
    mType = TObjectStoreAddParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStorePutParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move(aRhs));
    mType = TObjectStorePutParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreGetParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(aRhs);
    mType = TObjectStoreGetParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreGetParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move(aRhs));
    mType = TObjectStoreGetParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreGetKeyParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(aRhs);
    mType = TObjectStoreGetKeyParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreGetKeyParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move(aRhs));
    mType = TObjectStoreGetKeyParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreGetAllParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(aRhs);
    mType = TObjectStoreGetAllParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreGetAllParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move(aRhs));
    mType = TObjectStoreGetAllParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreGetAllKeysParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(aRhs);
    mType = TObjectStoreGetAllKeysParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreGetAllKeysParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move(aRhs));
    mType = TObjectStoreGetAllKeysParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreDeleteParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(aRhs);
    mType = TObjectStoreDeleteParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreDeleteParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move(aRhs));
    mType = TObjectStoreDeleteParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreClearParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(aRhs);
    mType = TObjectStoreClearParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreClearParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move(aRhs));
    mType = TObjectStoreClearParams;
    return (*(this));
}

auto RequestParams::operator=(const ObjectStoreCountParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(aRhs);
    mType = TObjectStoreCountParams;
    return (*(this));
}

auto RequestParams::operator=(ObjectStoreCountParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move(aRhs));
    mType = TObjectStoreCountParams;
    return (*(this));
}

auto RequestParams::operator=(const IndexGetParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(aRhs);
    mType = TIndexGetParams;
    return (*(this));
}

auto RequestParams::operator=(IndexGetParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move(aRhs));
    mType = TIndexGetParams;
    return (*(this));
}

auto RequestParams::operator=(const IndexGetKeyParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(aRhs);
    mType = TIndexGetKeyParams;
    return (*(this));
}

auto RequestParams::operator=(IndexGetKeyParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move(aRhs));
    mType = TIndexGetKeyParams;
    return (*(this));
}

auto RequestParams::operator=(const IndexGetAllParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(aRhs);
    mType = TIndexGetAllParams;
    return (*(this));
}

auto RequestParams::operator=(IndexGetAllParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move(aRhs));
    mType = TIndexGetAllParams;
    return (*(this));
}

auto RequestParams::operator=(const IndexGetAllKeysParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(aRhs);
    mType = TIndexGetAllKeysParams;
    return (*(this));
}

auto RequestParams::operator=(IndexGetAllKeysParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move(aRhs));
    mType = TIndexGetAllKeysParams;
    return (*(this));
}

auto RequestParams::operator=(const IndexCountParams& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(aRhs);
    mType = TIndexCountParams;
    return (*(this));
}

auto RequestParams::operator=(IndexCountParams&& aRhs) -> RequestParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move(aRhs));
    mType = TIndexCountParams;
    return (*(this));
}

auto RequestParams::operator=(RequestParams&& aRhs) -> RequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreAddParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move((aRhs).get_ObjectStoreAddParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStorePutParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move((aRhs).get_ObjectStorePutParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move((aRhs).get_ObjectStoreGetParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetKeyParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move((aRhs).get_ObjectStoreGetKeyParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move((aRhs).get_ObjectStoreGetAllParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllKeysParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move((aRhs).get_ObjectStoreGetAllKeysParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreDeleteParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move((aRhs).get_ObjectStoreDeleteParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreClearParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move((aRhs).get_ObjectStoreClearParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreCountParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move((aRhs).get_ObjectStoreCountParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move((aRhs).get_IndexGetParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetKeyParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move((aRhs).get_IndexGetKeyParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetAllParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move((aRhs).get_IndexGetAllParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetAllKeysParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move((aRhs).get_IndexGetAllKeysParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexCountParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move((aRhs).get_IndexCountParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TObjectStoreAddParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreAddParams());
            // Sentinel = 'TObjectStoreAddParams'
            (aWriter)->WriteSentinel(1479280678);
            return;
        }
    case union__::TObjectStorePutParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStorePutParams());
            // Sentinel = 'TObjectStorePutParams'
            (aWriter)->WriteSentinel(1504381014);
            return;
        }
    case union__::TObjectStoreGetParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetParams());
            // Sentinel = 'TObjectStoreGetParams'
            (aWriter)->WriteSentinel(1490683965);
            return;
        }
    case union__::TObjectStoreGetKeyParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetKeyParams());
            // Sentinel = 'TObjectStoreGetKeyParams'
            (aWriter)->WriteSentinel(1937705318);
            return;
        }
    case union__::TObjectStoreGetAllParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllParams());
            // Sentinel = 'TObjectStoreGetAllParams'
            (aWriter)->WriteSentinel(1929513302);
            return;
        }
    case union__::TObjectStoreGetAllKeysParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllKeysParams());
            // Sentinel = 'TObjectStoreGetAllKeysParams'
            (aWriter)->WriteSentinel(2620525298);
            return;
        }
    case union__::TObjectStoreDeleteParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreDeleteParams());
            // Sentinel = 'TObjectStoreDeleteParams'
            (aWriter)->WriteSentinel(1944127856);
            return;
        }
    case union__::TObjectStoreClearParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreClearParams());
            // Sentinel = 'TObjectStoreClearParams'
            (aWriter)->WriteSentinel(1782909188);
            return;
        }
    case union__::TObjectStoreCountParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreCountParams());
            // Sentinel = 'TObjectStoreCountParams'
            (aWriter)->WriteSentinel(1802045734);
            return;
        }
    case union__::TIndexGetParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetParams());
            // Sentinel = 'TIndexGetParams'
            (aWriter)->WriteSentinel(756418001);
            return;
        }
    case union__::TIndexGetKeyParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetKeyParams());
            // Sentinel = 'TIndexGetKeyParams'
            (aWriter)->WriteSentinel(1081542394);
            return;
        }
    case union__::TIndexGetAllParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetAllParams());
            // Sentinel = 'TIndexGetAllParams'
            (aWriter)->WriteSentinel(1073350378);
            return;
        }
    case union__::TIndexGetAllKeysParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetAllKeysParams());
            // Sentinel = 'TIndexGetAllKeysParams'
            (aWriter)->WriteSentinel(1601833094);
            return;
        }
    case union__::TIndexCountParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexCountParams());
            // Sentinel = 'TIndexCountParams'
            (aWriter)->WriteSentinel(986515130);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union RequestParams");
            return;
        }
    }
}

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

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

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

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreAddParams'
            if ((!((aReader)->ReadSentinel(1479280678)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreAddParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStorePutParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStorePutParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStorePutParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStorePutParams'
            if ((!((aReader)->ReadSentinel(1504381014)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStorePutParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreGetParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreGetParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreGetParams'
            if ((!((aReader)->ReadSentinel(1490683965)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreGetKeyParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreGetKeyParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreGetKeyParams'
            if ((!((aReader)->ReadSentinel(1937705318)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetKeyParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreGetAllParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreGetAllParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreGetAllParams'
            if ((!((aReader)->ReadSentinel(1929513302)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreGetAllKeysParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreGetAllKeysParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreGetAllKeysParams'
            if ((!((aReader)->ReadSentinel(2620525298)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllKeysParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreDeleteParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreDeleteParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreDeleteParams'
            if ((!((aReader)->ReadSentinel(1944127856)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreDeleteParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreClearParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreClearParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreClearParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreClearParams'
            if ((!((aReader)->ReadSentinel(1782909188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreClearParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TObjectStoreCountParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreCountParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TObjectStoreCountParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TObjectStoreCountParams'
            if ((!((aReader)->ReadSentinel(1802045734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreCountParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexGetParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexGetParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIndexGetParams'
            if ((!((aReader)->ReadSentinel(756418001)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexGetKeyParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetKeyParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexGetKeyParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIndexGetKeyParams'
            if ((!((aReader)->ReadSentinel(1081542394)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetKeyParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexGetAllParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetAllParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexGetAllParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIndexGetAllParams'
            if ((!((aReader)->ReadSentinel(1073350378)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexGetAllKeysParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetAllKeysParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexGetAllKeysParams of union RequestParams");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIndexGetAllKeysParams'
            if ((!((aReader)->ReadSentinel(1601833094)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllKeysParams of union RequestParams");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIndexCountParams:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexCountParams>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIndexCountParams of union RequestParams");
                return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LoggingInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto LoggingInfo::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(LoggingInfo, nextRequestSerialNumber_) - offsetof(LoggingInfo, nextTransactionSerialNumber_)) == 16,
        "Bad assumptions about field layout!");
}

} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::LoggingInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).backgroundChildLoggingId());
    // Sentinel = 'backgroundChildLoggingId'
    (aWriter)->WriteSentinel(2010253689);
    (aWriter)->WriteBytes((&((aVar).nextTransactionSerialNumber())), 24);
    // Sentinel = 'nextTransactionSerialNumber | nextVersionChangeTransactionSerialNumber | nextRequestSerialNumber'
    (aWriter)->WriteSentinel(1100293682);
}

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

    }
    auto& _backgroundChildLoggingId = *maybe___backgroundChildLoggingId;
    // Sentinel = 'backgroundChildLoggingId'
    if ((!((aReader)->ReadSentinel(2010253689)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'backgroundChildLoggingId' (nsID) member of 'LoggingInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_backgroundChildLoggingId),
            ::int64_t{0},
            ::int64_t{0},
            ::uint64_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->nextTransactionSerialNumber())), 24)))) {
        aReader->FatalError("Error bulk reading fields from int64_t");
        return {};
    }
    // Sentinel = 'nextTransactionSerialNumber | nextVersionChangeTransactionSerialNumber | nextRequestSerialNumber'
    if ((!((aReader)->ReadSentinel(1100293682)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
        return {};
    }
    return result__;
}

} // namespace IPC
