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


#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/indexedDB/ActorsChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBTransactionParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBTransactionChild.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBVersionChangeTransactionParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBVersionChangeTransactionChild.h"
#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBRequest.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBRequestParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBRequestChild.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"

namespace mozilla {
namespace dom {
namespace indexedDB {
namespace PBackgroundIDBRequest {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::indexedDB::PBackgroundIDBRequestParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::indexedDB::PBackgroundIDBRequestChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParentDestInfo, aChildDestInfo, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_Continue(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Continue__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_Preprocess(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Preprocess__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}

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

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

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

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

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

} // namespace IPC

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _cloneInfo = *maybe___cloneInfo;
    // Sentinel = 'cloneInfo'
    if ((!((aReader)->ReadSentinel(304284574)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfo' (SerializedStructuredCloneReadInfo) member of 'ObjectStoreGetResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cloneInfo)};
    return result__;
}

} // namespace IPC

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___cloneInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>>(aReader);
    if (!maybe___cloneInfos) {
        aReader->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllResponse'");
        return {};

    }
    auto& _cloneInfos = *maybe___cloneInfos;
    // Sentinel = 'cloneInfos'
    if ((!((aReader)->ReadSentinel(372507665)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cloneInfos)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keys = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::Key>>(aReader);
    if (!maybe___keys) {
        aReader->FatalError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllKeysResponse'");
        return {};

    }
    auto& _keys = *maybe___keys;
    // Sentinel = 'keys'
    if ((!((aReader)->ReadSentinel(71565757)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllKeysResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_keys)};
    return result__;
}

} // namespace IPC

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

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

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

} // namespace IPC

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

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

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

} // namespace IPC

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _cloneInfo = *maybe___cloneInfo;
    // Sentinel = 'cloneInfo'
    if ((!((aReader)->ReadSentinel(304284574)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfo' (SerializedStructuredCloneReadInfo) member of 'IndexGetResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cloneInfo)};
    return result__;
}

} // namespace IPC

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___cloneInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>>(aReader);
    if (!maybe___cloneInfos) {
        aReader->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllResponse'");
        return {};

    }
    auto& _cloneInfos = *maybe___cloneInfos;
    // Sentinel = 'cloneInfos'
    if ((!((aReader)->ReadSentinel(372507665)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cloneInfos)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllKeysResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keys = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::Key>>(aReader);
    if (!maybe___keys) {
        aReader->FatalError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllKeysResponse'");
        return {};

    }
    auto& _keys = *maybe___keys;
    // Sentinel = 'keys'
    if ((!((aReader)->ReadSentinel(71565757)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllKeysResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_keys)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllRecordsResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keys = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::Key>>(aReader);
    if (!maybe___keys) {
        aReader->FatalError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllRecordsResponse'");
        return {};

    }
    auto& _keys = *maybe___keys;
    // Sentinel = 'keys'
    if ((!((aReader)->ReadSentinel(71565757)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'ObjectStoreGetAllRecordsResponse'");
        return {};
    }
    auto maybe___cloneInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>>(aReader);
    if (!maybe___cloneInfos) {
        aReader->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllRecordsResponse'");
        return {};

    }
    auto& _cloneInfos = *maybe___cloneInfos;
    // Sentinel = 'cloneInfos'
    if ((!((aReader)->ReadSentinel(372507665)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'ObjectStoreGetAllRecordsResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_keys),
            std::move(_cloneInfos)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllRecordsResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).keys());
    // Sentinel = 'keys'
    (aWriter)->WriteSentinel(71565757);
    IPC::WriteParam(aWriter, (aVar).primaryKeys());
    // Sentinel = 'primaryKeys'
    (aWriter)->WriteSentinel(467141793);
    IPC::WriteParam(aWriter, (aVar).cloneInfos());
    // Sentinel = 'cloneInfos'
    (aWriter)->WriteSentinel(372507665);
}

auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllRecordsResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___keys = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::Key>>(aReader);
    if (!maybe___keys) {
        aReader->FatalError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllRecordsResponse'");
        return {};

    }
    auto& _keys = *maybe___keys;
    // Sentinel = 'keys'
    if ((!((aReader)->ReadSentinel(71565757)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keys' (Key[]) member of 'IndexGetAllRecordsResponse'");
        return {};
    }
    auto maybe___primaryKeys = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::Key>>(aReader);
    if (!maybe___primaryKeys) {
        aReader->FatalError("Error deserializing 'primaryKeys' (Key[]) member of 'IndexGetAllRecordsResponse'");
        return {};

    }
    auto& _primaryKeys = *maybe___primaryKeys;
    // Sentinel = 'primaryKeys'
    if ((!((aReader)->ReadSentinel(467141793)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'primaryKeys' (Key[]) member of 'IndexGetAllRecordsResponse'");
        return {};
    }
    auto maybe___cloneInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>>(aReader);
    if (!maybe___cloneInfos) {
        aReader->FatalError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllRecordsResponse'");
        return {};

    }
    auto& _cloneInfos = *maybe___cloneInfos;
    // Sentinel = 'cloneInfos'
    if ((!((aReader)->ReadSentinel(372507665)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfos' (SerializedStructuredCloneReadInfo[]) member of 'IndexGetAllRecordsResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_keys),
            std::move(_primaryKeys),
            std::move(_cloneInfos)};
    return result__;
}

} // namespace IPC

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto RequestResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TTransactionOpResult:
        {
            (ptr_TransactionOpResult())->~TransactionOpResult__tdef();
            break;
        }
    case TObjectStoreGetResponse:
        {
            (ptr_ObjectStoreGetResponse())->~ObjectStoreGetResponse__tdef();
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            (ptr_ObjectStoreGetKeyResponse())->~ObjectStoreGetKeyResponse__tdef();
            break;
        }
    case TObjectStoreAddResponse:
        {
            (ptr_ObjectStoreAddResponse())->~ObjectStoreAddResponse__tdef();
            break;
        }
    case TObjectStorePutResponse:
        {
            (ptr_ObjectStorePutResponse())->~ObjectStorePutResponse__tdef();
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            (ptr_ObjectStoreDeleteResponse())->~ObjectStoreDeleteResponse__tdef();
            break;
        }
    case TObjectStoreClearResponse:
        {
            (ptr_ObjectStoreClearResponse())->~ObjectStoreClearResponse__tdef();
            break;
        }
    case TObjectStoreCountResponse:
        {
            (ptr_ObjectStoreCountResponse())->~ObjectStoreCountResponse__tdef();
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            (ptr_ObjectStoreGetAllResponse())->~ObjectStoreGetAllResponse__tdef();
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            (ptr_ObjectStoreGetAllKeysResponse())->~ObjectStoreGetAllKeysResponse__tdef();
            break;
        }
    case TObjectStoreGetAllRecordsResponse:
        {
            (ptr_ObjectStoreGetAllRecordsResponse())->~ObjectStoreGetAllRecordsResponse__tdef();
            break;
        }
    case TIndexGetResponse:
        {
            (ptr_IndexGetResponse())->~IndexGetResponse__tdef();
            break;
        }
    case TIndexGetKeyResponse:
        {
            (ptr_IndexGetKeyResponse())->~IndexGetKeyResponse__tdef();
            break;
        }
    case TIndexGetAllResponse:
        {
            (ptr_IndexGetAllResponse())->~IndexGetAllResponse__tdef();
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            (ptr_IndexGetAllKeysResponse())->~IndexGetAllKeysResponse__tdef();
            break;
        }
    case TIndexGetAllRecordsResponse:
        {
            (ptr_IndexGetAllRecordsResponse())->~IndexGetAllRecordsResponse__tdef();
            break;
        }
    case TIndexCountResponse:
        {
            (ptr_IndexCountResponse())->~IndexCountResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const TransactionOpResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(aOther);
    mType = TTransactionOpResult;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(TransactionOpResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(std::move(aOther));
    mType = TTransactionOpResult;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move(aOther));
    mType = TObjectStoreGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetKeyResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(aOther);
    mType = TObjectStoreGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetKeyResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move(aOther));
    mType = TObjectStoreGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreAddResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(aOther);
    mType = TObjectStoreAddResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreAddResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move(aOther));
    mType = TObjectStoreAddResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStorePutResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(aOther);
    mType = TObjectStorePutResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStorePutResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move(aOther));
    mType = TObjectStorePutResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreDeleteResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(aOther);
    mType = TObjectStoreDeleteResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreDeleteResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move(aOther));
    mType = TObjectStoreDeleteResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreClearResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(aOther);
    mType = TObjectStoreClearResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreClearResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move(aOther));
    mType = TObjectStoreClearResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreCountResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(aOther);
    mType = TObjectStoreCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreCountResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move(aOther));
    mType = TObjectStoreCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move(aOther));
    mType = TObjectStoreGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ObjectStoreGetAllKeysResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(aOther);
    mType = TObjectStoreGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetAllKeysResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move(aOther));
    mType = TObjectStoreGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ObjectStoreGetAllRecordsResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllRecordsResponse()) ObjectStoreGetAllRecordsResponse(std::move(aOther));
    mType = TObjectStoreGetAllRecordsResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move(aOther));
    mType = TIndexGetResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetKeyResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(aOther);
    mType = TIndexGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetKeyResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move(aOther));
    mType = TIndexGetKeyResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move(aOther));
    mType = TIndexGetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexGetAllKeysResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(aOther);
    mType = TIndexGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetAllKeysResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move(aOther));
    mType = TIndexGetAllKeysResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexGetAllRecordsResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexGetAllRecordsResponse()) IndexGetAllRecordsResponse(std::move(aOther));
    mType = TIndexGetAllRecordsResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const IndexCountResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(aOther);
    mType = TIndexCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(IndexCountResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move(aOther));
    mType = TIndexCountResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(RequestResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TTransactionOpResult:
        {
            new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(std::move((aOther).get_TransactionOpResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move((aOther).get_ObjectStoreGetResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move((aOther).get_ObjectStoreGetKeyResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreAddResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move((aOther).get_ObjectStoreAddResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStorePutResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move((aOther).get_ObjectStorePutResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move((aOther).get_ObjectStoreDeleteResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreClearResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move((aOther).get_ObjectStoreClearResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move((aOther).get_ObjectStoreCountResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move((aOther).get_ObjectStoreGetAllResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move((aOther).get_ObjectStoreGetAllKeysResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllRecordsResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllRecordsResponse()) ObjectStoreGetAllRecordsResponse(std::move((aOther).get_ObjectStoreGetAllRecordsResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move((aOther).get_IndexGetResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetKeyResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move((aOther).get_IndexGetKeyResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move((aOther).get_IndexGetAllResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move((aOther).get_IndexGetAllKeysResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexGetAllRecordsResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexGetAllRecordsResponse()) IndexGetAllRecordsResponse(std::move((aOther).get_IndexGetAllRecordsResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIndexCountResponse:
        {
            new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move((aOther).get_IndexCountResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto RequestResponse::operator=(const TransactionOpResult& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(aRhs);
    mType = TTransactionOpResult;
    return (*(this));
}

auto RequestResponse::operator=(TransactionOpResult&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(std::move(aRhs));
    mType = TTransactionOpResult;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move(aRhs));
    mType = TObjectStoreGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetKeyResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(aRhs);
    mType = TObjectStoreGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetKeyResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move(aRhs));
    mType = TObjectStoreGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreAddResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(aRhs);
    mType = TObjectStoreAddResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreAddResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move(aRhs));
    mType = TObjectStoreAddResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStorePutResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(aRhs);
    mType = TObjectStorePutResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStorePutResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move(aRhs));
    mType = TObjectStorePutResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreDeleteResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(aRhs);
    mType = TObjectStoreDeleteResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreDeleteResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move(aRhs));
    mType = TObjectStoreDeleteResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreClearResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(aRhs);
    mType = TObjectStoreClearResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreClearResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move(aRhs));
    mType = TObjectStoreClearResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreCountResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(aRhs);
    mType = TObjectStoreCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreCountResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move(aRhs));
    mType = TObjectStoreCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetAllResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move(aRhs));
    mType = TObjectStoreGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ObjectStoreGetAllKeysResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(aRhs);
    mType = TObjectStoreGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetAllKeysResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move(aRhs));
    mType = TObjectStoreGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(ObjectStoreGetAllRecordsResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllRecordsResponse()) ObjectStoreGetAllRecordsResponse(std::move(aRhs));
    mType = TObjectStoreGetAllRecordsResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move(aRhs));
    mType = TIndexGetResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetKeyResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(aRhs);
    mType = TIndexGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetKeyResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move(aRhs));
    mType = TIndexGetKeyResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetAllResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move(aRhs));
    mType = TIndexGetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexGetAllKeysResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(aRhs);
    mType = TIndexGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetAllKeysResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move(aRhs));
    mType = TIndexGetAllKeysResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexGetAllRecordsResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexGetAllRecordsResponse()) IndexGetAllRecordsResponse(std::move(aRhs));
    mType = TIndexGetAllRecordsResponse;
    return (*(this));
}

auto RequestResponse::operator=(const IndexCountResponse& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(aRhs);
    mType = TIndexCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(IndexCountResponse&& aRhs) -> RequestResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move(aRhs));
    mType = TIndexCountResponse;
    return (*(this));
}

auto RequestResponse::operator=(RequestResponse&& aRhs) -> RequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TTransactionOpResult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_TransactionOpResult()) TransactionOpResult(std::move((aRhs).get_TransactionOpResult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetResponse()) ObjectStoreGetResponse(std::move((aRhs).get_ObjectStoreGetResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetKeyResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyResponse()) ObjectStoreGetKeyResponse(std::move((aRhs).get_ObjectStoreGetKeyResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreAddResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreAddResponse()) ObjectStoreAddResponse(std::move((aRhs).get_ObjectStoreAddResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStorePutResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStorePutResponse()) ObjectStorePutResponse(std::move((aRhs).get_ObjectStorePutResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreDeleteResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteResponse()) ObjectStoreDeleteResponse(std::move((aRhs).get_ObjectStoreDeleteResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreClearResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreClearResponse()) ObjectStoreClearResponse(std::move((aRhs).get_ObjectStoreClearResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreCountResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreCountResponse()) ObjectStoreCountResponse(std::move((aRhs).get_ObjectStoreCountResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllResponse()) ObjectStoreGetAllResponse(std::move((aRhs).get_ObjectStoreGetAllResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllKeysResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysResponse()) ObjectStoreGetAllKeysResponse(std::move((aRhs).get_ObjectStoreGetAllKeysResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllRecordsResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllRecordsResponse()) ObjectStoreGetAllRecordsResponse(std::move((aRhs).get_ObjectStoreGetAllRecordsResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetResponse()) IndexGetResponse(std::move((aRhs).get_IndexGetResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetKeyResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetKeyResponse()) IndexGetKeyResponse(std::move((aRhs).get_IndexGetKeyResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetAllResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetAllResponse()) IndexGetAllResponse(std::move((aRhs).get_IndexGetAllResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetAllKeysResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetAllKeysResponse()) IndexGetAllKeysResponse(std::move((aRhs).get_IndexGetAllKeysResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexGetAllRecordsResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexGetAllRecordsResponse()) IndexGetAllRecordsResponse(std::move((aRhs).get_IndexGetAllRecordsResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIndexCountResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IndexCountResponse()) IndexCountResponse(std::move((aRhs).get_IndexCountResponse()));
            (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::RequestResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::indexedDB::RequestResponse union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'RequestResponse'
    (aWriter)->WriteSentinel(822806073);

    switch (type) {
    case union__::TTransactionOpResult:
        {
            IPC::WriteParam(aWriter, (aVar).get_TransactionOpResult());
            // Sentinel = 'TTransactionOpResult'
            (aWriter)->WriteSentinel(1397884953);
            return;
        }
    case union__::TObjectStoreGetResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetResponse());
            // Sentinel = 'TObjectStoreGetResponse'
            (aWriter)->WriteSentinel(1796540712);
            return;
        }
    case union__::TObjectStoreGetKeyResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetKeyResponse());
            // Sentinel = 'TObjectStoreGetKeyResponse'
            (aWriter)->WriteSentinel(2282490449);
            return;
        }
    case union__::TObjectStoreAddResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreAddResponse());
            // Sentinel = 'TObjectStoreAddResponse'
            (aWriter)->WriteSentinel(1782122769);
            return;
        }
    case union__::TObjectStorePutResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStorePutResponse());
            // Sentinel = 'TObjectStorePutResponse'
            (aWriter)->WriteSentinel(1813514561);
            return;
        }
    case union__::TObjectStoreDeleteResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreDeleteResponse());
            // Sentinel = 'TObjectStoreDeleteResponse'
            (aWriter)->WriteSentinel(2290223707);
            return;
        }
    case union__::TObjectStoreClearResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreClearResponse());
            // Sentinel = 'TObjectStoreClearResponse'
            (aWriter)->WriteSentinel(2114849263);
            return;
        }
    case union__::TObjectStoreCountResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreCountResponse());
            // Sentinel = 'TObjectStoreCountResponse'
            (aWriter)->WriteSentinel(2138442257);
            return;
        }
    case union__::TObjectStoreGetAllResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllResponse());
            // Sentinel = 'TObjectStoreGetAllResponse'
            (aWriter)->WriteSentinel(2272201281);
            return;
        }
    case union__::TObjectStoreGetAllKeysResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllKeysResponse());
            // Sentinel = 'TObjectStoreGetAllKeysResponse'
            (aWriter)->WriteSentinel(3017214941);
            return;
        }
    case union__::TObjectStoreGetAllRecordsResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllRecordsResponse());
            // Sentinel = 'TObjectStoreGetAllRecordsResponse'
            (aWriter)->WriteSentinel(3648326931);
            return;
        }
    case union__::TIndexGetResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetResponse());
            // Sentinel = 'TIndexGetResponse'
            (aWriter)->WriteSentinel(981010108);
            return;
        }
    case union__::TIndexGetKeyResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetKeyResponse());
            // Sentinel = 'TIndexGetKeyResponse'
            (aWriter)->WriteSentinel(1345062885);
            return;
        }
    case union__::TIndexGetAllResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetAllResponse());
            // Sentinel = 'TIndexGetAllResponse'
            (aWriter)->WriteSentinel(1334773717);
            return;
        }
    case union__::TIndexGetAllKeysResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetAllKeysResponse());
            // Sentinel = 'TIndexGetAllKeysResponse'
            (aWriter)->WriteSentinel(1917258097);
            return;
        }
    case union__::TIndexGetAllRecordsResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexGetAllRecordsResponse());
            // Sentinel = 'TIndexGetAllRecordsResponse'
            (aWriter)->WriteSentinel(2426473127);
            return;
        }
    case union__::TIndexCountResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IndexCountResponse());
            // Sentinel = 'TIndexCountResponse'
            (aWriter)->WriteSentinel(1241647013);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union RequestResponse");
            return;
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::PreprocessInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___files = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>>(aReader);
    if (!maybe___files) {
        aReader->FatalError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'PreprocessInfo'");
        return {};

    }
    auto& _files = *maybe___files;
    // Sentinel = 'files'
    if ((!((aReader)->ReadSentinel(103285268)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'PreprocessInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_files)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _preprocessInfo = *maybe___preprocessInfo;
    // Sentinel = 'preprocessInfo'
    if ((!((aReader)->ReadSentinel(743704019)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preprocessInfo' (PreprocessInfo) member of 'ObjectStoreGetPreprocessParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_preprocessInfo)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___preprocessInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::PreprocessInfo>>(aReader);
    if (!maybe___preprocessInfos) {
        aReader->FatalError("Error deserializing 'preprocessInfos' (PreprocessInfo[]) member of 'ObjectStoreGetAllPreprocessParams'");
        return {};

    }
    auto& _preprocessInfos = *maybe___preprocessInfos;
    // Sentinel = 'preprocessInfos'
    if ((!((aReader)->ReadSentinel(848954950)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'preprocessInfos' (PreprocessInfo[]) member of 'ObjectStoreGetAllPreprocessParams'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_preprocessInfos)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto PreprocessParams::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TObjectStoreGetPreprocessParams:
        {
            (ptr_ObjectStoreGetPreprocessParams())->~ObjectStoreGetPreprocessParams__tdef();
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            (ptr_ObjectStoreGetAllPreprocessParams())->~ObjectStoreGetAllPreprocessParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const ObjectStoreGetPreprocessParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(aOther);
    mType = TObjectStoreGetPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(ObjectStoreGetPreprocessParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move(aOther));
    mType = TObjectStoreGetPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const ObjectStoreGetAllPreprocessParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(aOther);
    mType = TObjectStoreGetAllPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(ObjectStoreGetAllPreprocessParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move(aOther));
    mType = TObjectStoreGetAllPreprocessParams;
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(const PreprocessParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TObjectStoreGetPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams((aOther).get_ObjectStoreGetPreprocessParams());
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams((aOther).get_ObjectStoreGetAllPreprocessParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PreprocessParams::PreprocessParams(PreprocessParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move((aOther).get_ObjectStoreGetPreprocessParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move((aOther).get_ObjectStoreGetAllPreprocessParams()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto PreprocessParams::operator=(const ObjectStoreGetPreprocessParams& aRhs) -> PreprocessParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(aRhs);
    mType = TObjectStoreGetPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(ObjectStoreGetPreprocessParams&& aRhs) -> PreprocessParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move(aRhs));
    mType = TObjectStoreGetPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(const ObjectStoreGetAllPreprocessParams& aRhs) -> PreprocessParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(aRhs);
    mType = TObjectStoreGetAllPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(ObjectStoreGetAllPreprocessParams&& aRhs) -> PreprocessParams&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move(aRhs));
    mType = TObjectStoreGetAllPreprocessParams;
    return (*(this));
}

auto PreprocessParams::operator=(const PreprocessParams& aRhs) -> PreprocessParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams((aRhs).get_ObjectStoreGetPreprocessParams());
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams((aRhs).get_ObjectStoreGetAllPreprocessParams());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto PreprocessParams::operator=(PreprocessParams&& aRhs) -> PreprocessParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TObjectStoreGetPreprocessParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessParams()) ObjectStoreGetPreprocessParams(std::move((aRhs).get_ObjectStoreGetPreprocessParams()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllPreprocessParams:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessParams()) ObjectStoreGetAllPreprocessParams(std::move((aRhs).get_ObjectStoreGetAllPreprocessParams()));
            (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::PreprocessParams>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::indexedDB::PreprocessParams union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'PreprocessParams'
    (aWriter)->WriteSentinel(926287499);

    switch (type) {
    case union__::TObjectStoreGetPreprocessParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetPreprocessParams());
            // Sentinel = 'TObjectStoreGetPreprocessParams'
            (aWriter)->WriteSentinel(3262975075);
            return;
        }
    case union__::TObjectStoreGetAllPreprocessParams:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllPreprocessParams());
            // Sentinel = 'TObjectStoreGetAllPreprocessParams'
            (aWriter)->WriteSentinel(3885960572);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union PreprocessParams");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

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

} // namespace IPC

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

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

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto PreprocessResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            (ptr_ObjectStoreGetPreprocessResponse())->~ObjectStoreGetPreprocessResponse__tdef();
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            (ptr_ObjectStoreGetAllPreprocessResponse())->~ObjectStoreGetAllPreprocessResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const ObjectStoreGetPreprocessResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(aOther);
    mType = TObjectStoreGetPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(ObjectStoreGetPreprocessResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move(aOther));
    mType = TObjectStoreGetPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const ObjectStoreGetAllPreprocessResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(aOther);
    mType = TObjectStoreGetAllPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(ObjectStoreGetAllPreprocessResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move(aOther));
    mType = TObjectStoreGetAllPreprocessResponse;
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(const PreprocessResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse((aOther).get_ObjectStoreGetPreprocessResponse());
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse((aOther).get_ObjectStoreGetAllPreprocessResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PreprocessResponse::PreprocessResponse(PreprocessResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move((aOther).get_ObjectStoreGetPreprocessResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move((aOther).get_ObjectStoreGetAllPreprocessResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto PreprocessResponse::operator=(const ObjectStoreGetPreprocessResponse& aRhs) -> PreprocessResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(aRhs);
    mType = TObjectStoreGetPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(ObjectStoreGetPreprocessResponse&& aRhs) -> PreprocessResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move(aRhs));
    mType = TObjectStoreGetPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(const ObjectStoreGetAllPreprocessResponse& aRhs) -> PreprocessResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(aRhs);
    mType = TObjectStoreGetAllPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(ObjectStoreGetAllPreprocessResponse&& aRhs) -> PreprocessResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move(aRhs));
    mType = TObjectStoreGetAllPreprocessResponse;
    return (*(this));
}

auto PreprocessResponse::operator=(const PreprocessResponse& aRhs) -> PreprocessResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse((aRhs).get_ObjectStoreGetPreprocessResponse());
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse((aRhs).get_ObjectStoreGetAllPreprocessResponse());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto PreprocessResponse::operator=(PreprocessResponse&& aRhs) -> PreprocessResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetPreprocessResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetPreprocessResponse()) ObjectStoreGetPreprocessResponse(std::move((aRhs).get_ObjectStoreGetPreprocessResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TObjectStoreGetAllPreprocessResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllPreprocessResponse()) ObjectStoreGetAllPreprocessResponse(std::move((aRhs).get_ObjectStoreGetAllPreprocessResponse()));
            (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::PreprocessResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::indexedDB::PreprocessResponse union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'PreprocessResponse'
    (aWriter)->WriteSentinel(1175258998);

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TObjectStoreGetPreprocessResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetPreprocessResponse());
            // Sentinel = 'TObjectStoreGetPreprocessResponse'
            (aWriter)->WriteSentinel(3708030286);
            return;
        }
    case union__::TObjectStoreGetAllPreprocessResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllPreprocessResponse());
            // Sentinel = 'TObjectStoreGetAllPreprocessResponse'
            (aWriter)->WriteSentinel(73862759);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union PreprocessResponse");
            return;
        }
    }
}

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

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

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

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

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

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

} // namespace IPC