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

#ifndef PBackgroundIDBRequest_h
#define PBackgroundIDBRequest_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/dom/indexedDB/Key.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreAddResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreAddResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreAddResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreAddResponse(const Key& _key) :
        key_(_key)
    {
    }

    MOZ_IMPLICIT ObjectStoreAddResponse(Key&& _key) :
        key_(std::move(_key))
    {
    }

    Key&
    key()
    {
        return key_;
    }
    const Key&
    key() const
    {
        return key_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreAddResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreAddResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStorePutResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStorePutResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStorePutResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStorePutResponse(const Key& _key) :
        key_(_key)
    {
    }

    MOZ_IMPLICIT ObjectStorePutResponse(Key&& _key) :
        key_(std::move(_key))
    {
    }

    Key&
    key()
    {
        return key_;
    }
    const Key&
    key() const
    {
        return key_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStorePutResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStorePutResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetResponse(SerializedStructuredCloneReadInfo&& _cloneInfo) :
        cloneInfo_(std::move(_cloneInfo))
    {
    }

    SerializedStructuredCloneReadInfo&
    cloneInfo()
    {
        return cloneInfo_;
    }
    const SerializedStructuredCloneReadInfo&
    cloneInfo() const
    {
        return cloneInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SerializedStructuredCloneReadInfo> cloneInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetKeyResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetKeyResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetKeyResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetKeyResponse(const Key& _key) :
        key_(_key)
    {
    }

    MOZ_IMPLICIT ObjectStoreGetKeyResponse(Key&& _key) :
        key_(std::move(_key))
    {
    }

    Key&
    key()
    {
        return key_;
    }
    const Key&
    key() const
    {
        return key_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetAllResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetAllResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetAllResponse(nsTArray<SerializedStructuredCloneReadInfo>&& _cloneInfos) :
        cloneInfos_(std::move(_cloneInfos))
    {
    }

    nsTArray<SerializedStructuredCloneReadInfo>&
    cloneInfos()
    {
        return cloneInfos_;
    }
    const nsTArray<SerializedStructuredCloneReadInfo>&
    cloneInfos() const
    {
        return cloneInfos_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneReadInfo>> cloneInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetAllKeysResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllKeysResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetAllKeysResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetAllKeysResponse(const nsTArray<Key>& _keys) :
        keys_(_keys)
    {
    }

    MOZ_IMPLICIT ObjectStoreGetAllKeysResponse(nsTArray<Key>&& _keys) :
        keys_(std::move(_keys))
    {
    }

    nsTArray<Key>&
    keys()
    {
        return keys_;
    }
    const nsTArray<Key>&
    keys() const
    {
        return keys_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<Key>> keys_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreDeleteResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreDeleteResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreDeleteResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreDeleteResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreDeleteResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreClearResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreClearResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreClearResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreClearResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreClearResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreCountResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreCountResponse final
{
private:
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreCountResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreCountResponse(const uint64_t& _count) :
        count_(_count)
    {
    }

    MOZ_IMPLICIT ObjectStoreCountResponse(uint64_t&& _count) :
        count_(std::move(_count))
    {
    }

    uint64_t&
    count()
    {
        return count_;
    }
    const uint64_t&
    count() const
    {
        return count_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint64_t> count_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreCountResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreCountResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IndexGetResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IndexGetResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IndexGetResponse(SerializedStructuredCloneReadInfo&& _cloneInfo) :
        cloneInfo_(std::move(_cloneInfo))
    {
    }

    SerializedStructuredCloneReadInfo&
    cloneInfo()
    {
        return cloneInfo_;
    }
    const SerializedStructuredCloneReadInfo&
    cloneInfo() const
    {
        return cloneInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SerializedStructuredCloneReadInfo> cloneInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetResponse>
{
    typedef ::mozilla::dom::indexedDB::IndexGetResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IndexGetKeyResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetKeyResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IndexGetKeyResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IndexGetKeyResponse(const Key& _key) :
        key_(_key)
    {
    }

    MOZ_IMPLICIT IndexGetKeyResponse(Key&& _key) :
        key_(std::move(_key))
    {
    }

    Key&
    key()
    {
        return key_;
    }
    const Key&
    key() const
    {
        return key_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetKeyResponse>
{
    typedef ::mozilla::dom::indexedDB::IndexGetKeyResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IndexGetAllResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetAllResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IndexGetAllResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IndexGetAllResponse(nsTArray<SerializedStructuredCloneReadInfo>&& _cloneInfos) :
        cloneInfos_(std::move(_cloneInfos))
    {
    }

    nsTArray<SerializedStructuredCloneReadInfo>&
    cloneInfos()
    {
        return cloneInfos_;
    }
    const nsTArray<SerializedStructuredCloneReadInfo>&
    cloneInfos() const
    {
        return cloneInfos_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneReadInfo>> cloneInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetAllResponse>
{
    typedef ::mozilla::dom::indexedDB::IndexGetAllResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IndexGetAllKeysResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetAllKeysResponse final
{
private:
    typedef ::mozilla::dom::indexedDB::Key Key;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IndexGetAllKeysResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IndexGetAllKeysResponse(const nsTArray<Key>& _keys) :
        keys_(_keys)
    {
    }

    MOZ_IMPLICIT IndexGetAllKeysResponse(nsTArray<Key>&& _keys) :
        keys_(std::move(_keys))
    {
    }

    nsTArray<Key>&
    keys()
    {
        return keys_;
    }
    const nsTArray<Key>&
    keys() const
    {
        return keys_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<Key>> keys_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetAllKeysResponse>
{
    typedef ::mozilla::dom::indexedDB::IndexGetAllKeysResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IndexCountResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexCountResponse final
{
private:
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IndexCountResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IndexCountResponse(const uint64_t& _count) :
        count_(_count)
    {
    }

    MOZ_IMPLICIT IndexCountResponse(uint64_t&& _count) :
        count_(std::move(_count))
    {
    }

    uint64_t&
    count()
    {
        return count_;
    }
    const uint64_t&
    count() const
    {
        return count_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint64_t> count_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexCountResponse>
{
    typedef ::mozilla::dom::indexedDB::IndexCountResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union RequestResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class RequestResponse final
{
public:
    enum Type {
        T__None,
        Tnsresult = 1,
        TObjectStoreGetResponse,
        TObjectStoreGetKeyResponse,
        TObjectStoreAddResponse,
        TObjectStorePutResponse,
        TObjectStoreDeleteResponse,
        TObjectStoreClearResponse,
        TObjectStoreCountResponse,
        TObjectStoreGetAllResponse,
        TObjectStoreGetAllKeysResponse,
        TIndexGetResponse,
        TIndexGetKeyResponse,
        TIndexGetAllResponse,
        TIndexGetAllKeysResponse,
        TIndexCountResponse,
        T__Last = TIndexCountResponse
    };

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetResponse ObjectStoreGetResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse ObjectStoreGetKeyResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreAddResponse ObjectStoreAddResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStorePutResponse ObjectStorePutResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreDeleteResponse ObjectStoreDeleteResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreClearResponse ObjectStoreClearResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreCountResponse ObjectStoreCountResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllResponse ObjectStoreGetAllResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse ObjectStoreGetAllKeysResponse;
    typedef ::mozilla::dom::indexedDB::IndexGetResponse IndexGetResponse;
    typedef ::mozilla::dom::indexedDB::IndexGetKeyResponse IndexGetKeyResponse;
    typedef ::mozilla::dom::indexedDB::IndexGetAllResponse IndexGetAllResponse;
    typedef ::mozilla::dom::indexedDB::IndexGetAllKeysResponse IndexGetAllKeysResponse;
    typedef ::mozilla::dom::indexedDB::IndexCountResponse IndexCountResponse;
    typedef nsresult nsresult__tdef;
    typedef ObjectStoreGetResponse ObjectStoreGetResponse__tdef;
    typedef ObjectStoreGetKeyResponse ObjectStoreGetKeyResponse__tdef;
    typedef ObjectStoreAddResponse ObjectStoreAddResponse__tdef;
    typedef ObjectStorePutResponse ObjectStorePutResponse__tdef;
    typedef ObjectStoreDeleteResponse ObjectStoreDeleteResponse__tdef;
    typedef ObjectStoreClearResponse ObjectStoreClearResponse__tdef;
    typedef ObjectStoreCountResponse ObjectStoreCountResponse__tdef;
    typedef ObjectStoreGetAllResponse ObjectStoreGetAllResponse__tdef;
    typedef ObjectStoreGetAllKeysResponse ObjectStoreGetAllKeysResponse__tdef;
    typedef IndexGetResponse IndexGetResponse__tdef;
    typedef IndexGetKeyResponse IndexGetKeyResponse__tdef;
    typedef IndexGetAllResponse IndexGetAllResponse__tdef;
    typedef IndexGetAllKeysResponse IndexGetAllKeysResponse__tdef;
    typedef IndexCountResponse IndexCountResponse__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    ObjectStoreGetResponse*
    ptr_ObjectStoreGetResponse()
    {
        return (&(mVObjectStoreGetResponse));
    }
    const ObjectStoreGetResponse*
    constptr_ObjectStoreGetResponse() const
    {
        return (&(mVObjectStoreGetResponse));
    }
    ObjectStoreGetKeyResponse*
    ptr_ObjectStoreGetKeyResponse()
    {
        return (&(mVObjectStoreGetKeyResponse));
    }
    const ObjectStoreGetKeyResponse*
    constptr_ObjectStoreGetKeyResponse() const
    {
        return (&(mVObjectStoreGetKeyResponse));
    }
    ObjectStoreAddResponse*
    ptr_ObjectStoreAddResponse()
    {
        return (&(mVObjectStoreAddResponse));
    }
    const ObjectStoreAddResponse*
    constptr_ObjectStoreAddResponse() const
    {
        return (&(mVObjectStoreAddResponse));
    }
    ObjectStorePutResponse*
    ptr_ObjectStorePutResponse()
    {
        return (&(mVObjectStorePutResponse));
    }
    const ObjectStorePutResponse*
    constptr_ObjectStorePutResponse() const
    {
        return (&(mVObjectStorePutResponse));
    }
    ObjectStoreDeleteResponse*
    ptr_ObjectStoreDeleteResponse()
    {
        return (&(mVObjectStoreDeleteResponse));
    }
    const ObjectStoreDeleteResponse*
    constptr_ObjectStoreDeleteResponse() const
    {
        return (&(mVObjectStoreDeleteResponse));
    }
    ObjectStoreClearResponse*
    ptr_ObjectStoreClearResponse()
    {
        return (&(mVObjectStoreClearResponse));
    }
    const ObjectStoreClearResponse*
    constptr_ObjectStoreClearResponse() const
    {
        return (&(mVObjectStoreClearResponse));
    }
    ObjectStoreCountResponse*
    ptr_ObjectStoreCountResponse()
    {
        return (&(mVObjectStoreCountResponse));
    }
    const ObjectStoreCountResponse*
    constptr_ObjectStoreCountResponse() const
    {
        return (&(mVObjectStoreCountResponse));
    }
    ObjectStoreGetAllResponse*
    ptr_ObjectStoreGetAllResponse()
    {
        return (&(mVObjectStoreGetAllResponse));
    }
    const ObjectStoreGetAllResponse*
    constptr_ObjectStoreGetAllResponse() const
    {
        return (&(mVObjectStoreGetAllResponse));
    }
    ObjectStoreGetAllKeysResponse*
    ptr_ObjectStoreGetAllKeysResponse()
    {
        return (&(mVObjectStoreGetAllKeysResponse));
    }
    const ObjectStoreGetAllKeysResponse*
    constptr_ObjectStoreGetAllKeysResponse() const
    {
        return (&(mVObjectStoreGetAllKeysResponse));
    }
    IndexGetResponse*
    ptr_IndexGetResponse()
    {
        return (&(mVIndexGetResponse));
    }
    const IndexGetResponse*
    constptr_IndexGetResponse() const
    {
        return (&(mVIndexGetResponse));
    }
    IndexGetKeyResponse*
    ptr_IndexGetKeyResponse()
    {
        return (&(mVIndexGetKeyResponse));
    }
    const IndexGetKeyResponse*
    constptr_IndexGetKeyResponse() const
    {
        return (&(mVIndexGetKeyResponse));
    }
    IndexGetAllResponse*
    ptr_IndexGetAllResponse()
    {
        return (&(mVIndexGetAllResponse));
    }
    const IndexGetAllResponse*
    constptr_IndexGetAllResponse() const
    {
        return (&(mVIndexGetAllResponse));
    }
    IndexGetAllKeysResponse*
    ptr_IndexGetAllKeysResponse()
    {
        return (&(mVIndexGetAllKeysResponse));
    }
    const IndexGetAllKeysResponse*
    constptr_IndexGetAllKeysResponse() const
    {
        return (&(mVIndexGetAllKeysResponse));
    }
    IndexCountResponse*
    ptr_IndexCountResponse()
    {
        return (&(mVIndexCountResponse));
    }
    const IndexCountResponse*
    constptr_IndexCountResponse() const
    {
        return (&(mVIndexCountResponse));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT RequestResponse() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT RequestResponse(const nsresult& aOther);

    MOZ_IMPLICIT RequestResponse(nsresult&& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreGetResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreGetKeyResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreGetKeyResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreAddResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreAddResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStorePutResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStorePutResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreDeleteResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreDeleteResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreClearResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreClearResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreCountResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreCountResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreGetAllResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const ObjectStoreGetAllKeysResponse& aOther);

    MOZ_IMPLICIT RequestResponse(ObjectStoreGetAllKeysResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(IndexGetResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const IndexGetKeyResponse& aOther);

    MOZ_IMPLICIT RequestResponse(IndexGetKeyResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(IndexGetAllResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const IndexGetAllKeysResponse& aOther);

    MOZ_IMPLICIT RequestResponse(IndexGetAllKeysResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(const IndexCountResponse& aOther);

    MOZ_IMPLICIT RequestResponse(IndexCountResponse&& aOther);

    MOZ_IMPLICIT RequestResponse(RequestResponse&& aOther);

    ~RequestResponse();

    Type
    type() const
    {
        return mType;
    }

    RequestResponse&
    operator=(const nsresult& aRhs);

    RequestResponse&
    operator=(nsresult&& aRhs);

    RequestResponse&
    operator=(ObjectStoreGetResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreGetKeyResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreGetKeyResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreAddResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreAddResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStorePutResponse& aRhs);

    RequestResponse&
    operator=(ObjectStorePutResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreDeleteResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreDeleteResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreClearResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreClearResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreCountResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreCountResponse&& aRhs);

    RequestResponse&
    operator=(ObjectStoreGetAllResponse&& aRhs);

    RequestResponse&
    operator=(const ObjectStoreGetAllKeysResponse& aRhs);

    RequestResponse&
    operator=(ObjectStoreGetAllKeysResponse&& aRhs);

    RequestResponse&
    operator=(IndexGetResponse&& aRhs);

    RequestResponse&
    operator=(const IndexGetKeyResponse& aRhs);

    RequestResponse&
    operator=(IndexGetKeyResponse&& aRhs);

    RequestResponse&
    operator=(IndexGetAllResponse&& aRhs);

    RequestResponse&
    operator=(const IndexGetAllKeysResponse& aRhs);

    RequestResponse&
    operator=(IndexGetAllKeysResponse&& aRhs);

    RequestResponse&
    operator=(const IndexCountResponse& aRhs);

    RequestResponse&
    operator=(IndexCountResponse&& aRhs);

    RequestResponse&
    operator=(RequestResponse&& aRhs);

    nsresult&
    get_nsresult()
    {
        AssertSanity(Tnsresult);
        return (*(ptr_nsresult()));
    }
    const nsresult&
    get_nsresult() const
    {
        AssertSanity(Tnsresult);
        return (*(constptr_nsresult()));
    }
    operator nsresult&()
    {
        return get_nsresult();
    }
    operator const nsresult&() const
    {
        return get_nsresult();
    }

    ObjectStoreGetResponse&
    get_ObjectStoreGetResponse()
    {
        AssertSanity(TObjectStoreGetResponse);
        return (*(ptr_ObjectStoreGetResponse()));
    }
    const ObjectStoreGetResponse&
    get_ObjectStoreGetResponse() const
    {
        AssertSanity(TObjectStoreGetResponse);
        return (*(constptr_ObjectStoreGetResponse()));
    }
    operator ObjectStoreGetResponse&()
    {
        return get_ObjectStoreGetResponse();
    }
    operator const ObjectStoreGetResponse&() const
    {
        return get_ObjectStoreGetResponse();
    }

    ObjectStoreGetKeyResponse&
    get_ObjectStoreGetKeyResponse()
    {
        AssertSanity(TObjectStoreGetKeyResponse);
        return (*(ptr_ObjectStoreGetKeyResponse()));
    }
    const ObjectStoreGetKeyResponse&
    get_ObjectStoreGetKeyResponse() const
    {
        AssertSanity(TObjectStoreGetKeyResponse);
        return (*(constptr_ObjectStoreGetKeyResponse()));
    }
    operator ObjectStoreGetKeyResponse&()
    {
        return get_ObjectStoreGetKeyResponse();
    }
    operator const ObjectStoreGetKeyResponse&() const
    {
        return get_ObjectStoreGetKeyResponse();
    }

    ObjectStoreAddResponse&
    get_ObjectStoreAddResponse()
    {
        AssertSanity(TObjectStoreAddResponse);
        return (*(ptr_ObjectStoreAddResponse()));
    }
    const ObjectStoreAddResponse&
    get_ObjectStoreAddResponse() const
    {
        AssertSanity(TObjectStoreAddResponse);
        return (*(constptr_ObjectStoreAddResponse()));
    }
    operator ObjectStoreAddResponse&()
    {
        return get_ObjectStoreAddResponse();
    }
    operator const ObjectStoreAddResponse&() const
    {
        return get_ObjectStoreAddResponse();
    }

    ObjectStorePutResponse&
    get_ObjectStorePutResponse()
    {
        AssertSanity(TObjectStorePutResponse);
        return (*(ptr_ObjectStorePutResponse()));
    }
    const ObjectStorePutResponse&
    get_ObjectStorePutResponse() const
    {
        AssertSanity(TObjectStorePutResponse);
        return (*(constptr_ObjectStorePutResponse()));
    }
    operator ObjectStorePutResponse&()
    {
        return get_ObjectStorePutResponse();
    }
    operator const ObjectStorePutResponse&() const
    {
        return get_ObjectStorePutResponse();
    }

    ObjectStoreDeleteResponse&
    get_ObjectStoreDeleteResponse()
    {
        AssertSanity(TObjectStoreDeleteResponse);
        return (*(ptr_ObjectStoreDeleteResponse()));
    }
    const ObjectStoreDeleteResponse&
    get_ObjectStoreDeleteResponse() const
    {
        AssertSanity(TObjectStoreDeleteResponse);
        return (*(constptr_ObjectStoreDeleteResponse()));
    }
    operator ObjectStoreDeleteResponse&()
    {
        return get_ObjectStoreDeleteResponse();
    }
    operator const ObjectStoreDeleteResponse&() const
    {
        return get_ObjectStoreDeleteResponse();
    }

    ObjectStoreClearResponse&
    get_ObjectStoreClearResponse()
    {
        AssertSanity(TObjectStoreClearResponse);
        return (*(ptr_ObjectStoreClearResponse()));
    }
    const ObjectStoreClearResponse&
    get_ObjectStoreClearResponse() const
    {
        AssertSanity(TObjectStoreClearResponse);
        return (*(constptr_ObjectStoreClearResponse()));
    }
    operator ObjectStoreClearResponse&()
    {
        return get_ObjectStoreClearResponse();
    }
    operator const ObjectStoreClearResponse&() const
    {
        return get_ObjectStoreClearResponse();
    }

    ObjectStoreCountResponse&
    get_ObjectStoreCountResponse()
    {
        AssertSanity(TObjectStoreCountResponse);
        return (*(ptr_ObjectStoreCountResponse()));
    }
    const ObjectStoreCountResponse&
    get_ObjectStoreCountResponse() const
    {
        AssertSanity(TObjectStoreCountResponse);
        return (*(constptr_ObjectStoreCountResponse()));
    }
    operator ObjectStoreCountResponse&()
    {
        return get_ObjectStoreCountResponse();
    }
    operator const ObjectStoreCountResponse&() const
    {
        return get_ObjectStoreCountResponse();
    }

    ObjectStoreGetAllResponse&
    get_ObjectStoreGetAllResponse()
    {
        AssertSanity(TObjectStoreGetAllResponse);
        return (*(ptr_ObjectStoreGetAllResponse()));
    }
    const ObjectStoreGetAllResponse&
    get_ObjectStoreGetAllResponse() const
    {
        AssertSanity(TObjectStoreGetAllResponse);
        return (*(constptr_ObjectStoreGetAllResponse()));
    }
    operator ObjectStoreGetAllResponse&()
    {
        return get_ObjectStoreGetAllResponse();
    }
    operator const ObjectStoreGetAllResponse&() const
    {
        return get_ObjectStoreGetAllResponse();
    }

    ObjectStoreGetAllKeysResponse&
    get_ObjectStoreGetAllKeysResponse()
    {
        AssertSanity(TObjectStoreGetAllKeysResponse);
        return (*(ptr_ObjectStoreGetAllKeysResponse()));
    }
    const ObjectStoreGetAllKeysResponse&
    get_ObjectStoreGetAllKeysResponse() const
    {
        AssertSanity(TObjectStoreGetAllKeysResponse);
        return (*(constptr_ObjectStoreGetAllKeysResponse()));
    }
    operator ObjectStoreGetAllKeysResponse&()
    {
        return get_ObjectStoreGetAllKeysResponse();
    }
    operator const ObjectStoreGetAllKeysResponse&() const
    {
        return get_ObjectStoreGetAllKeysResponse();
    }

    IndexGetResponse&
    get_IndexGetResponse()
    {
        AssertSanity(TIndexGetResponse);
        return (*(ptr_IndexGetResponse()));
    }
    const IndexGetResponse&
    get_IndexGetResponse() const
    {
        AssertSanity(TIndexGetResponse);
        return (*(constptr_IndexGetResponse()));
    }
    operator IndexGetResponse&()
    {
        return get_IndexGetResponse();
    }
    operator const IndexGetResponse&() const
    {
        return get_IndexGetResponse();
    }

    IndexGetKeyResponse&
    get_IndexGetKeyResponse()
    {
        AssertSanity(TIndexGetKeyResponse);
        return (*(ptr_IndexGetKeyResponse()));
    }
    const IndexGetKeyResponse&
    get_IndexGetKeyResponse() const
    {
        AssertSanity(TIndexGetKeyResponse);
        return (*(constptr_IndexGetKeyResponse()));
    }
    operator IndexGetKeyResponse&()
    {
        return get_IndexGetKeyResponse();
    }
    operator const IndexGetKeyResponse&() const
    {
        return get_IndexGetKeyResponse();
    }

    IndexGetAllResponse&
    get_IndexGetAllResponse()
    {
        AssertSanity(TIndexGetAllResponse);
        return (*(ptr_IndexGetAllResponse()));
    }
    const IndexGetAllResponse&
    get_IndexGetAllResponse() const
    {
        AssertSanity(TIndexGetAllResponse);
        return (*(constptr_IndexGetAllResponse()));
    }
    operator IndexGetAllResponse&()
    {
        return get_IndexGetAllResponse();
    }
    operator const IndexGetAllResponse&() const
    {
        return get_IndexGetAllResponse();
    }

    IndexGetAllKeysResponse&
    get_IndexGetAllKeysResponse()
    {
        AssertSanity(TIndexGetAllKeysResponse);
        return (*(ptr_IndexGetAllKeysResponse()));
    }
    const IndexGetAllKeysResponse&
    get_IndexGetAllKeysResponse() const
    {
        AssertSanity(TIndexGetAllKeysResponse);
        return (*(constptr_IndexGetAllKeysResponse()));
    }
    operator IndexGetAllKeysResponse&()
    {
        return get_IndexGetAllKeysResponse();
    }
    operator const IndexGetAllKeysResponse&() const
    {
        return get_IndexGetAllKeysResponse();
    }

    IndexCountResponse&
    get_IndexCountResponse()
    {
        AssertSanity(TIndexCountResponse);
        return (*(ptr_IndexCountResponse()));
    }
    const IndexCountResponse&
    get_IndexCountResponse() const
    {
        AssertSanity(TIndexCountResponse);
        return (*(constptr_IndexCountResponse()));
    }
    operator IndexCountResponse&()
    {
        return get_IndexCountResponse();
    }
    operator const IndexCountResponse&() const
    {
        return get_IndexCountResponse();
    }

private:
    union {
        nsresult mVnsresult;
        ObjectStoreGetResponse mVObjectStoreGetResponse;
        ObjectStoreGetKeyResponse mVObjectStoreGetKeyResponse;
        ObjectStoreAddResponse mVObjectStoreAddResponse;
        ObjectStorePutResponse mVObjectStorePutResponse;
        ObjectStoreDeleteResponse mVObjectStoreDeleteResponse;
        ObjectStoreClearResponse mVObjectStoreClearResponse;
        ObjectStoreCountResponse mVObjectStoreCountResponse;
        ObjectStoreGetAllResponse mVObjectStoreGetAllResponse;
        ObjectStoreGetAllKeysResponse mVObjectStoreGetAllKeysResponse;
        IndexGetResponse mVIndexGetResponse;
        IndexGetKeyResponse mVIndexGetKeyResponse;
        IndexGetAllResponse mVIndexGetAllResponse;
        IndexGetAllKeysResponse mVIndexGetAllKeysResponse;
        IndexCountResponse mVIndexCountResponse;
    };
    Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::RequestResponse>
{
    typedef ::mozilla::dom::indexedDB::RequestResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct PreprocessInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessInfo final
{
private:
    typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneFile SerializedStructuredCloneFile;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    PreprocessInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT PreprocessInfo(const nsTArray<SerializedStructuredCloneFile>& _files) :
        files_(_files)
    {
    }

    MOZ_IMPLICIT PreprocessInfo(nsTArray<SerializedStructuredCloneFile>&& _files) :
        files_(std::move(_files))
    {
    }

    nsTArray<SerializedStructuredCloneFile>&
    files()
    {
        return files_;
    }
    const nsTArray<SerializedStructuredCloneFile>&
    files() const
    {
        return files_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneFile>> files_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessInfo>
{
    typedef ::mozilla::dom::indexedDB::PreprocessInfo paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetPreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetPreprocessParams final
{
private:
    typedef ::mozilla::dom::indexedDB::PreprocessInfo PreprocessInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetPreprocessParams() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetPreprocessParams(const PreprocessInfo& _preprocessInfo) :
        preprocessInfo_(_preprocessInfo)
    {
    }

    MOZ_IMPLICIT ObjectStoreGetPreprocessParams(PreprocessInfo&& _preprocessInfo) :
        preprocessInfo_(std::move(_preprocessInfo))
    {
    }

    PreprocessInfo&
    preprocessInfo()
    {
        return preprocessInfo_;
    }
    const PreprocessInfo&
    preprocessInfo() const
    {
        return preprocessInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PreprocessInfo> preprocessInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetAllPreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllPreprocessParams final
{
private:
    typedef ::mozilla::dom::indexedDB::PreprocessInfo PreprocessInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetAllPreprocessParams() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectStoreGetAllPreprocessParams(const nsTArray<PreprocessInfo>& _preprocessInfos) :
        preprocessInfos_(_preprocessInfos)
    {
    }

    MOZ_IMPLICIT ObjectStoreGetAllPreprocessParams(nsTArray<PreprocessInfo>&& _preprocessInfos) :
        preprocessInfos_(std::move(_preprocessInfos))
    {
    }

    nsTArray<PreprocessInfo>&
    preprocessInfos()
    {
        return preprocessInfos_;
    }
    const nsTArray<PreprocessInfo>&
    preprocessInfos() const
    {
        return preprocessInfos_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<PreprocessInfo>> preprocessInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union PreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessParams final
{
public:
    enum Type {
        T__None,
        TObjectStoreGetPreprocessParams = 1,
        TObjectStoreGetAllPreprocessParams,
        T__Last = TObjectStoreGetAllPreprocessParams
    };

private:
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams ObjectStoreGetPreprocessParams;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams ObjectStoreGetAllPreprocessParams;
    typedef ObjectStoreGetPreprocessParams ObjectStoreGetPreprocessParams__tdef;
    typedef ObjectStoreGetAllPreprocessParams ObjectStoreGetAllPreprocessParams__tdef;

    ObjectStoreGetPreprocessParams*
    ptr_ObjectStoreGetPreprocessParams()
    {
        return (&(mVObjectStoreGetPreprocessParams));
    }
    const ObjectStoreGetPreprocessParams*
    constptr_ObjectStoreGetPreprocessParams() const
    {
        return (&(mVObjectStoreGetPreprocessParams));
    }
    ObjectStoreGetAllPreprocessParams*
    ptr_ObjectStoreGetAllPreprocessParams()
    {
        return (&(mVObjectStoreGetAllPreprocessParams));
    }
    const ObjectStoreGetAllPreprocessParams*
    constptr_ObjectStoreGetAllPreprocessParams() const
    {
        return (&(mVObjectStoreGetAllPreprocessParams));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT PreprocessParams() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT PreprocessParams(const ObjectStoreGetPreprocessParams& aOther);

    MOZ_IMPLICIT PreprocessParams(ObjectStoreGetPreprocessParams&& aOther);

    MOZ_IMPLICIT PreprocessParams(const ObjectStoreGetAllPreprocessParams& aOther);

    MOZ_IMPLICIT PreprocessParams(ObjectStoreGetAllPreprocessParams&& aOther);

    MOZ_IMPLICIT PreprocessParams(const PreprocessParams& aOther);

    MOZ_IMPLICIT PreprocessParams(PreprocessParams&& aOther);

    ~PreprocessParams();

    Type
    type() const
    {
        return mType;
    }

    PreprocessParams&
    operator=(const ObjectStoreGetPreprocessParams& aRhs);

    PreprocessParams&
    operator=(ObjectStoreGetPreprocessParams&& aRhs);

    PreprocessParams&
    operator=(const ObjectStoreGetAllPreprocessParams& aRhs);

    PreprocessParams&
    operator=(ObjectStoreGetAllPreprocessParams&& aRhs);

    PreprocessParams&
    operator=(const PreprocessParams& aRhs);

    PreprocessParams&
    operator=(PreprocessParams&& aRhs);

    ObjectStoreGetPreprocessParams&
    get_ObjectStoreGetPreprocessParams()
    {
        AssertSanity(TObjectStoreGetPreprocessParams);
        return (*(ptr_ObjectStoreGetPreprocessParams()));
    }
    const ObjectStoreGetPreprocessParams&
    get_ObjectStoreGetPreprocessParams() const
    {
        AssertSanity(TObjectStoreGetPreprocessParams);
        return (*(constptr_ObjectStoreGetPreprocessParams()));
    }
    operator ObjectStoreGetPreprocessParams&()
    {
        return get_ObjectStoreGetPreprocessParams();
    }
    operator const ObjectStoreGetPreprocessParams&() const
    {
        return get_ObjectStoreGetPreprocessParams();
    }

    ObjectStoreGetAllPreprocessParams&
    get_ObjectStoreGetAllPreprocessParams()
    {
        AssertSanity(TObjectStoreGetAllPreprocessParams);
        return (*(ptr_ObjectStoreGetAllPreprocessParams()));
    }
    const ObjectStoreGetAllPreprocessParams&
    get_ObjectStoreGetAllPreprocessParams() const
    {
        AssertSanity(TObjectStoreGetAllPreprocessParams);
        return (*(constptr_ObjectStoreGetAllPreprocessParams()));
    }
    operator ObjectStoreGetAllPreprocessParams&()
    {
        return get_ObjectStoreGetAllPreprocessParams();
    }
    operator const ObjectStoreGetAllPreprocessParams&() const
    {
        return get_ObjectStoreGetAllPreprocessParams();
    }

private:
    union {
        ObjectStoreGetPreprocessParams mVObjectStoreGetPreprocessParams;
        ObjectStoreGetAllPreprocessParams mVObjectStoreGetAllPreprocessParams;
    };
    Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessParams>
{
    typedef ::mozilla::dom::indexedDB::PreprocessParams paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetPreprocessResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetPreprocessResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreGetAllPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllPreprocessResponse final
{
private:

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectStoreGetAllPreprocessResponse() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse>
{
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union PreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessResponse final
{
public:
    enum Type {
        T__None,
        Tnsresult = 1,
        TObjectStoreGetPreprocessResponse,
        TObjectStoreGetAllPreprocessResponse,
        T__Last = TObjectStoreGetAllPreprocessResponse
    };

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse ObjectStoreGetPreprocessResponse;
    typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse ObjectStoreGetAllPreprocessResponse;
    typedef nsresult nsresult__tdef;
    typedef ObjectStoreGetPreprocessResponse ObjectStoreGetPreprocessResponse__tdef;
    typedef ObjectStoreGetAllPreprocessResponse ObjectStoreGetAllPreprocessResponse__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    ObjectStoreGetPreprocessResponse*
    ptr_ObjectStoreGetPreprocessResponse()
    {
        return (&(mVObjectStoreGetPreprocessResponse));
    }
    const ObjectStoreGetPreprocessResponse*
    constptr_ObjectStoreGetPreprocessResponse() const
    {
        return (&(mVObjectStoreGetPreprocessResponse));
    }
    ObjectStoreGetAllPreprocessResponse*
    ptr_ObjectStoreGetAllPreprocessResponse()
    {
        return (&(mVObjectStoreGetAllPreprocessResponse));
    }
    const ObjectStoreGetAllPreprocessResponse*
    constptr_ObjectStoreGetAllPreprocessResponse() const
    {
        return (&(mVObjectStoreGetAllPreprocessResponse));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT PreprocessResponse() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT PreprocessResponse(const nsresult& aOther);

    MOZ_IMPLICIT PreprocessResponse(nsresult&& aOther);

    MOZ_IMPLICIT PreprocessResponse(const ObjectStoreGetPreprocessResponse& aOther);

    MOZ_IMPLICIT PreprocessResponse(ObjectStoreGetPreprocessResponse&& aOther);

    MOZ_IMPLICIT PreprocessResponse(const ObjectStoreGetAllPreprocessResponse& aOther);

    MOZ_IMPLICIT PreprocessResponse(ObjectStoreGetAllPreprocessResponse&& aOther);

    MOZ_IMPLICIT PreprocessResponse(const PreprocessResponse& aOther);

    MOZ_IMPLICIT PreprocessResponse(PreprocessResponse&& aOther);

    ~PreprocessResponse();

    Type
    type() const
    {
        return mType;
    }

    PreprocessResponse&
    operator=(const nsresult& aRhs);

    PreprocessResponse&
    operator=(nsresult&& aRhs);

    PreprocessResponse&
    operator=(const ObjectStoreGetPreprocessResponse& aRhs);

    PreprocessResponse&
    operator=(ObjectStoreGetPreprocessResponse&& aRhs);

    PreprocessResponse&
    operator=(const ObjectStoreGetAllPreprocessResponse& aRhs);

    PreprocessResponse&
    operator=(ObjectStoreGetAllPreprocessResponse&& aRhs);

    PreprocessResponse&
    operator=(const PreprocessResponse& aRhs);

    PreprocessResponse&
    operator=(PreprocessResponse&& aRhs);

    nsresult&
    get_nsresult()
    {
        AssertSanity(Tnsresult);
        return (*(ptr_nsresult()));
    }
    const nsresult&
    get_nsresult() const
    {
        AssertSanity(Tnsresult);
        return (*(constptr_nsresult()));
    }
    operator nsresult&()
    {
        return get_nsresult();
    }
    operator const nsresult&() const
    {
        return get_nsresult();
    }

    ObjectStoreGetPreprocessResponse&
    get_ObjectStoreGetPreprocessResponse()
    {
        AssertSanity(TObjectStoreGetPreprocessResponse);
        return (*(ptr_ObjectStoreGetPreprocessResponse()));
    }
    const ObjectStoreGetPreprocessResponse&
    get_ObjectStoreGetPreprocessResponse() const
    {
        AssertSanity(TObjectStoreGetPreprocessResponse);
        return (*(constptr_ObjectStoreGetPreprocessResponse()));
    }
    operator ObjectStoreGetPreprocessResponse&()
    {
        return get_ObjectStoreGetPreprocessResponse();
    }
    operator const ObjectStoreGetPreprocessResponse&() const
    {
        return get_ObjectStoreGetPreprocessResponse();
    }

    ObjectStoreGetAllPreprocessResponse&
    get_ObjectStoreGetAllPreprocessResponse()
    {
        AssertSanity(TObjectStoreGetAllPreprocessResponse);
        return (*(ptr_ObjectStoreGetAllPreprocessResponse()));
    }
    const ObjectStoreGetAllPreprocessResponse&
    get_ObjectStoreGetAllPreprocessResponse() const
    {
        AssertSanity(TObjectStoreGetAllPreprocessResponse);
        return (*(constptr_ObjectStoreGetAllPreprocessResponse()));
    }
    operator ObjectStoreGetAllPreprocessResponse&()
    {
        return get_ObjectStoreGetAllPreprocessResponse();
    }
    operator const ObjectStoreGetAllPreprocessResponse&() const
    {
        return get_ObjectStoreGetAllPreprocessResponse();
    }

private:
    union {
        nsresult mVnsresult;
        ObjectStoreGetPreprocessResponse mVObjectStoreGetPreprocessResponse;
        ObjectStoreGetAllPreprocessResponse mVObjectStoreGetAllPreprocessResponse;
    };
    Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessResponse>
{
    typedef ::mozilla::dom::indexedDB::PreprocessResponse paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBRequestParent;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBRequestChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PBackgroundIDBRequestChild and PBackgroundIDBRequestParent
//
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);

enum MessageType {
    PBackgroundIDBRequestStart = PBackgroundIDBRequestMsgStart << 16,
    Msg_Continue__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    Msg_Preprocess__ID,
    PBackgroundIDBRequestEnd
};

mozilla::UniquePtr<IPC::Message>
Msg_Continue(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Preprocess(IPC::Message::routeid_t routingId);



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

#endif // ifndef PBackgroundIDBRequest_h
