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


#include "mozilla/dom/PFileSystemAccessHandleParent.h"
#include "mozilla/dom/PFileSystemAccessHandleChild.h"
#include "mozilla/dom/PFileSystemAccessHandleControlParent.h"
#include "mozilla/dom/PFileSystemAccessHandleControlChild.h"
#include "mozilla/dom/PFileSystemWritableFileStreamParent.h"
#include "mozilla/dom/PFileSystemWritableFileStreamChild.h"
#include "mozilla/dom/PFileSystemManager.h"
#include "mozilla/dom/PFileSystemManagerParent.h"
#include "mozilla/dom/PFileSystemManagerChild.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 PFileSystemManager {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParentDestInfo, aChildDestInfo, aParent, aChild);
}
nsresult
CreateEndpoints(
        mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemManagerChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_GetRootHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetRootHandle__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_GetRootHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetRootHandle__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_GetDirectoryHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetDirectoryHandle__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_GetDirectoryHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetDirectoryHandle__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_GetFileHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetFileHandle__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_GetFileHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetFileHandle__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_GetFile(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetFile__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_GetFile(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetFile__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_GetAccessHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetAccessHandle__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_GetAccessHandle(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetAccessHandle__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_GetWritable(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetWritable__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_GetWritable(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetWritable__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_Resolve(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Resolve__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_Resolve(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_Resolve__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_GetEntries(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetEntries__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_GetEntries(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetEntries__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_RemoveEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RemoveEntry__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_RemoveEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_RemoveEntry__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_MoveEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_MoveEntry__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_MoveEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_MoveEntry__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_RenameEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RenameEntry__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_RenameEntry(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_RenameEntry__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_PFileSystemWritableFileStreamConstructor(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_PFileSystemWritableFileStreamConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_PFileSystemWritableFileStreamConstructor(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_PFileSystemWritableFileStreamConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_CloseAll(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_CloseAll__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_CloseAll(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_CloseAll__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));
}

} // namespace PFileSystemManager
} // namespace dom
} // namespace mozilla

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).entryId());
    // Sentinel = 'entryId'
    (aWriter)->WriteSentinel(197853920);
    IPC::WriteParam(aWriter, (aVar).entryName());
    // Sentinel = 'entryName'
    (aWriter)->WriteSentinel(315950004);
    IPC::WriteParam(aWriter, (aVar).directory());
    // Sentinel = 'directory'
    (aWriter)->WriteSentinel(314180566);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemEntryMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___entryId) {
        aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemEntryMetadata'");
        return {};

    }
    auto& _entryId = *maybe___entryId;
    // Sentinel = 'entryId'
    if ((!((aReader)->ReadSentinel(197853920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemEntryMetadata'");
        return {};
    }
    auto maybe___entryName = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
    if (!maybe___entryName) {
        aReader->FatalError("Error deserializing 'entryName' (Name) member of 'FileSystemEntryMetadata'");
        return {};

    }
    auto& _entryName = *maybe___entryName;
    // Sentinel = 'entryName'
    if ((!((aReader)->ReadSentinel(315950004)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryName' (Name) member of 'FileSystemEntryMetadata'");
        return {};
    }
    auto maybe___directory = IPC::ReadParam<bool>(aReader);
    if (!maybe___directory) {
        aReader->FatalError("Error deserializing 'directory' (bool) member of 'FileSystemEntryMetadata'");
        return {};

    }
    auto& _directory = *maybe___directory;
    // Sentinel = 'directory'
    if ((!((aReader)->ReadSentinel(314180566)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'directory' (bool) member of 'FileSystemEntryMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_entryId),
            std::move(_entryName),
            std::move(_directory)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemChildMetadata>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).parentId());
    // Sentinel = 'parentId'
    (aWriter)->WriteSentinel(249430840);
    IPC::WriteParam(aWriter, (aVar).childName());
    // Sentinel = 'childName'
    (aWriter)->WriteSentinel(297337734);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemChildMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___parentId) {
        aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemChildMetadata'");
        return {};

    }
    auto& _parentId = *maybe___parentId;
    // Sentinel = 'parentId'
    if ((!((aReader)->ReadSentinel(249430840)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemChildMetadata'");
        return {};
    }
    auto maybe___childName = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
    if (!maybe___childName) {
        aReader->FatalError("Error deserializing 'childName' (Name) member of 'FileSystemChildMetadata'");
        return {};

    }
    auto& _childName = *maybe___childName;
    // Sentinel = 'childName'
    if ((!((aReader)->ReadSentinel(297337734)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'childName' (Name) member of 'FileSystemChildMetadata'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_parentId),
            std::move(_childName)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).handle());
    // Sentinel = 'handle'
    (aWriter)->WriteSentinel(142344813);
    IPC::WriteParam(aWriter, (aVar).create());
    // Sentinel = 'create'
    (aWriter)->WriteSentinel(144048757);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemGetHandleRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
    if (!maybe___handle) {
        aReader->FatalError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemGetHandleRequest'");
        return {};

    }
    auto& _handle = *maybe___handle;
    // Sentinel = 'handle'
    if ((!((aReader)->ReadSentinel(142344813)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemGetHandleRequest'");
        return {};
    }
    auto maybe___create = IPC::ReadParam<bool>(aReader);
    if (!maybe___create) {
        aReader->FatalError("Error deserializing 'create' (bool) member of 'FileSystemGetHandleRequest'");
        return {};

    }
    auto& _create = *maybe___create;
    // Sentinel = 'create'
    if ((!((aReader)->ReadSentinel(144048757)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'create' (bool) member of 'FileSystemGetHandleRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_handle),
            std::move(_create)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetHandleResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetHandleResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TEntryId:
        {
            (ptr_EntryId())->~EntryId__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(const EntryId& aOther)
{
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aOther);
    mType = TEntryId;
}

MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(EntryId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aOther));
    mType = TEntryId;
}

MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(const FileSystemGetHandleResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TEntryId:
        {
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aOther).get_EntryId());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemGetHandleResponse::FileSystemGetHandleResponse(FileSystemGetHandleResponse&& 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 TEntryId:
        {
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aOther).get_EntryId()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemGetHandleResponse::operator=(const EntryId& aRhs) -> FileSystemGetHandleResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aRhs);
    mType = TEntryId;
    return (*(this));
}

auto FileSystemGetHandleResponse::operator=(EntryId&& aRhs) -> FileSystemGetHandleResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aRhs));
    mType = TEntryId;
    return (*(this));
}

auto FileSystemGetHandleResponse::operator=(const FileSystemGetHandleResponse& aRhs) -> FileSystemGetHandleResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TEntryId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aRhs).get_EntryId());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemGetHandleResponse::operator=(FileSystemGetHandleResponse&& aRhs) -> FileSystemGetHandleResponse&
{
    (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 TEntryId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aRhs).get_EntryId()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TEntryId:
        {
            IPC::WriteParam(aWriter, (aVar).get_EntryId());
            // Sentinel = 'TEntryId'
            (aWriter)->WriteSentinel(227279636);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemGetHandleResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).parentId());
    // Sentinel = 'parentId'
    (aWriter)->WriteSentinel(249430840);
    IPC::WriteParam(aWriter, (aVar).page());
    // Sentinel = 'page'
    (aWriter)->WriteSentinel(68813214);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemGetEntriesRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___parentId) {
        aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemGetEntriesRequest'");
        return {};

    }
    auto& _parentId = *maybe___parentId;
    // Sentinel = 'parentId'
    if ((!((aReader)->ReadSentinel(249430840)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemGetEntriesRequest'");
        return {};
    }
    auto maybe___page = IPC::ReadParam<::mozilla::dom::fs::PageNumber>(aReader);
    if (!maybe___page) {
        aReader->FatalError("Error deserializing 'page' (PageNumber) member of 'FileSystemGetEntriesRequest'");
        return {};

    }
    auto& _page = *maybe___page;
    // Sentinel = 'page'
    if ((!((aReader)->ReadSentinel(68813214)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'page' (PageNumber) member of 'FileSystemGetEntriesRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_parentId),
            std::move(_page)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemDirectoryListing>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___directories = IPC::ReadParam<nsTArray<::mozilla::dom::fs::FileSystemEntryMetadata>>(aReader);
    if (!maybe___directories) {
        aReader->FatalError("Error deserializing 'directories' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
        return {};

    }
    auto& _directories = *maybe___directories;
    // Sentinel = 'directories'
    if ((!((aReader)->ReadSentinel(460522654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'directories' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
        return {};
    }
    auto maybe___files = IPC::ReadParam<nsTArray<::mozilla::dom::fs::FileSystemEntryMetadata>>(aReader);
    if (!maybe___files) {
        aReader->FatalError("Error deserializing 'files' (FileSystemEntryMetadata[]) member of 'FileSystemDirectoryListing'");
        return {};

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

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetEntriesResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetEntriesResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TFileSystemDirectoryListing:
        {
            (ptr_FileSystemDirectoryListing())->~FileSystemDirectoryListing__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(const FileSystemDirectoryListing& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(aOther);
    mType = TFileSystemDirectoryListing;
}

MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(FileSystemDirectoryListing&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move(aOther));
    mType = TFileSystemDirectoryListing;
}

MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(const FileSystemGetEntriesResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TFileSystemDirectoryListing:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing((aOther).get_FileSystemDirectoryListing());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemGetEntriesResponse::FileSystemGetEntriesResponse(FileSystemGetEntriesResponse&& 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 TFileSystemDirectoryListing:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move((aOther).get_FileSystemDirectoryListing()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemGetEntriesResponse::operator=(const FileSystemDirectoryListing& aRhs) -> FileSystemGetEntriesResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(aRhs);
    mType = TFileSystemDirectoryListing;
    return (*(this));
}

auto FileSystemGetEntriesResponse::operator=(FileSystemDirectoryListing&& aRhs) -> FileSystemGetEntriesResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move(aRhs));
    mType = TFileSystemDirectoryListing;
    return (*(this));
}

auto FileSystemGetEntriesResponse::operator=(const FileSystemGetEntriesResponse& aRhs) -> FileSystemGetEntriesResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TFileSystemDirectoryListing:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing((aRhs).get_FileSystemDirectoryListing());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemGetEntriesResponse::operator=(FileSystemGetEntriesResponse&& aRhs) -> FileSystemGetEntriesResponse&
{
    (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 TFileSystemDirectoryListing:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemDirectoryListing()) FileSystemDirectoryListing(std::move((aRhs).get_FileSystemDirectoryListing()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TFileSystemDirectoryListing:
        {
            IPC::WriteParam(aWriter, (aVar).get_FileSystemDirectoryListing());
            // Sentinel = 'TFileSystemDirectoryListing'
            (aWriter)->WriteSentinel(2501905129);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemGetEntriesResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemGetFileRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___entryId) {
        aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetFileRequest'");
        return {};

    }
    auto& _entryId = *maybe___entryId;
    // Sentinel = 'entryId'
    if ((!((aReader)->ReadSentinel(197853920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetFileRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_entryId)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _last_modified_ms = *maybe___last_modified_ms;
    // Sentinel = 'last_modified_ms'
    if ((!((aReader)->ReadSentinel(941950612)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'last_modified_ms' (TimeStamp) member of 'FileSystemFileProperties'");
        return {};
    }
    auto maybe___file = IPC::ReadParam<::mozilla::dom::IPCBlob>(aReader);
    if (!maybe___file) {
        aReader->FatalError("Error deserializing 'file' (IPCBlob) member of 'FileSystemFileProperties'");
        return {};

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

    }
    auto& _type = *maybe___type;
    // Sentinel = 'type'
    if ((!((aReader)->ReadSentinel(75760067)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (ContentType) member of 'FileSystemFileProperties'");
        return {};
    }
    auto maybe___path = IPC::ReadParam<nsTArray<::mozilla::dom::fs::Name>>(aReader);
    if (!maybe___path) {
        aReader->FatalError("Error deserializing 'path' (Name[]) member of 'FileSystemFileProperties'");
        return {};

    }
    auto& _path = *maybe___path;
    // Sentinel = 'path'
    if ((!((aReader)->ReadSentinel(70713774)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'path' (Name[]) member of 'FileSystemFileProperties'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_last_modified_ms),
            std::move(_file),
            std::move(_type),
            std::move(_path)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetFileResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetFileResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TFileSystemFileProperties:
        {
            (ptr_FileSystemFileProperties())->~FileSystemFileProperties__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(const FileSystemFileProperties& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(aOther);
    mType = TFileSystemFileProperties;
}

MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(FileSystemFileProperties&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move(aOther));
    mType = TFileSystemFileProperties;
}

MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(const FileSystemGetFileResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TFileSystemFileProperties:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties((aOther).get_FileSystemFileProperties());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemGetFileResponse::FileSystemGetFileResponse(FileSystemGetFileResponse&& 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 TFileSystemFileProperties:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move((aOther).get_FileSystemFileProperties()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemGetFileResponse::operator=(const FileSystemFileProperties& aRhs) -> FileSystemGetFileResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(aRhs);
    mType = TFileSystemFileProperties;
    return (*(this));
}

auto FileSystemGetFileResponse::operator=(FileSystemFileProperties&& aRhs) -> FileSystemGetFileResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move(aRhs));
    mType = TFileSystemFileProperties;
    return (*(this));
}

auto FileSystemGetFileResponse::operator=(const FileSystemGetFileResponse& aRhs) -> FileSystemGetFileResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TFileSystemFileProperties:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties((aRhs).get_FileSystemFileProperties());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemGetFileResponse::operator=(FileSystemGetFileResponse&& aRhs) -> FileSystemGetFileResponse&
{
    (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 TFileSystemFileProperties:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemFileProperties()) FileSystemFileProperties(std::move((aRhs).get_FileSystemFileProperties()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TFileSystemFileProperties:
        {
            IPC::WriteParam(aWriter, (aVar).get_FileSystemFileProperties());
            // Sentinel = 'TFileSystemFileProperties'
            (aWriter)->WriteSentinel(2129332743);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemGetFileResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemGetAccessHandleRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___entryId) {
        aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetAccessHandleRequest'");
        return {};

    }
    auto& _entryId = *maybe___entryId;
    // Sentinel = 'entryId'
    if ((!((aReader)->ReadSentinel(197853920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetAccessHandleRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_entryId)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemAccessHandleProperties>::Write(
        IPC::MessageWriter* aWriter,
        paramType&& aVar) -> void
{
    IPC::WriteParam(aWriter, std::move((aVar).streamParams()));
    // Sentinel = 'streamParams'
    (aWriter)->WriteSentinel(544015601);
    IPC::WriteParam(aWriter, std::move((aVar).accessHandleChildEndpoint()));
    // Sentinel = 'accessHandleChildEndpoint'
    (aWriter)->WriteSentinel(2129201636);
    IPC::WriteParam(aWriter, std::move((aVar).accessHandleControlChildEndpoint()));
    // Sentinel = 'accessHandleControlChildEndpoint'
    (aWriter)->WriteSentinel(3499363525);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemAccessHandleProperties>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___streamParams = IPC::ReadParam<::mozilla::ipc::RandomAccessStreamParams>(aReader);
    if (!maybe___streamParams) {
        aReader->FatalError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemAccessHandleProperties'");
        return {};

    }
    auto& _streamParams = *maybe___streamParams;
    // Sentinel = 'streamParams'
    if ((!((aReader)->ReadSentinel(544015601)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemAccessHandleProperties'");
        return {};
    }
    auto maybe___accessHandleChildEndpoint = IPC::ReadParam<::mozilla::ipc::ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>>(aReader);
    if (!maybe___accessHandleChildEndpoint) {
        aReader->FatalError("Error deserializing 'accessHandleChildEndpoint' (ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>) member of 'FileSystemAccessHandleProperties'");
        return {};

    }
    auto& _accessHandleChildEndpoint = *maybe___accessHandleChildEndpoint;
    // Sentinel = 'accessHandleChildEndpoint'
    if ((!((aReader)->ReadSentinel(2129201636)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'accessHandleChildEndpoint' (ManagedEndpoint<::mozilla::dom::PFileSystemAccessHandleChild>) member of 'FileSystemAccessHandleProperties'");
        return {};
    }
    auto maybe___accessHandleControlChildEndpoint = IPC::ReadParam<::mozilla::ipc::Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>>(aReader);
    if (!maybe___accessHandleControlChildEndpoint) {
        aReader->FatalError("Error deserializing 'accessHandleControlChildEndpoint' (Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>) member of 'FileSystemAccessHandleProperties'");
        return {};

    }
    auto& _accessHandleControlChildEndpoint = *maybe___accessHandleControlChildEndpoint;
    // Sentinel = 'accessHandleControlChildEndpoint'
    if ((!((aReader)->ReadSentinel(3499363525)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'accessHandleControlChildEndpoint' (Endpoint<::mozilla::dom::PFileSystemAccessHandleControlChild>) member of 'FileSystemAccessHandleProperties'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_streamParams),
            std::move(_accessHandleChildEndpoint),
            std::move(_accessHandleControlChildEndpoint)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetAccessHandleResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetAccessHandleResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TFileSystemAccessHandleProperties:
        {
            (ptr_FileSystemAccessHandleProperties())->~FileSystemAccessHandleProperties__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(FileSystemAccessHandleProperties&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move(aOther));
    mType = TFileSystemAccessHandleProperties;
}

MOZ_IMPLICIT FileSystemGetAccessHandleResponse::FileSystemGetAccessHandleResponse(FileSystemGetAccessHandleResponse&& 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 TFileSystemAccessHandleProperties:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move((aOther).get_FileSystemAccessHandleProperties()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemGetAccessHandleResponse::operator=(FileSystemAccessHandleProperties&& aRhs) -> FileSystemGetAccessHandleResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move(aRhs));
    mType = TFileSystemAccessHandleProperties;
    return (*(this));
}

auto FileSystemGetAccessHandleResponse::operator=(FileSystemGetAccessHandleResponse&& aRhs) -> FileSystemGetAccessHandleResponse&
{
    (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 TFileSystemAccessHandleProperties:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemAccessHandleProperties()) FileSystemAccessHandleProperties(std::move((aRhs).get_FileSystemAccessHandleProperties()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TFileSystemAccessHandleProperties:
        {
            IPC::WriteParam(aWriter, std::move((aVar).get_FileSystemAccessHandleProperties()));
            // Sentinel = 'TFileSystemAccessHandleProperties'
            (aWriter)->WriteSentinel(3665956133);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemGetAccessHandleResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).entryId());
    // Sentinel = 'entryId'
    (aWriter)->WriteSentinel(197853920);
    IPC::WriteParam(aWriter, (aVar).keepData());
    // Sentinel = 'keepData'
    (aWriter)->WriteSentinel(237830944);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemGetWritableRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___entryId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___entryId) {
        aReader->FatalError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetWritableRequest'");
        return {};

    }
    auto& _entryId = *maybe___entryId;
    // Sentinel = 'entryId'
    if ((!((aReader)->ReadSentinel(197853920)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'entryId' (EntryId) member of 'FileSystemGetWritableRequest'");
        return {};
    }
    auto maybe___keepData = IPC::ReadParam<bool>(aReader);
    if (!maybe___keepData) {
        aReader->FatalError("Error deserializing 'keepData' (bool) member of 'FileSystemGetWritableRequest'");
        return {};

    }
    auto& _keepData = *maybe___keepData;
    // Sentinel = 'keepData'
    if ((!((aReader)->ReadSentinel(237830944)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'keepData' (bool) member of 'FileSystemGetWritableRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_entryId),
            std::move(_keepData)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemWritableFileStreamProperties>::Write(
        IPC::MessageWriter* aWriter,
        paramType&& aVar) -> void
{
    IPC::WriteParam(aWriter, std::move((aVar).streamParams()));
    // Sentinel = 'streamParams'
    (aWriter)->WriteSentinel(544015601);
    IPC::WriteParam(aWriter, (aVar).writableFileStream());
    // Sentinel = 'writableFileStream'
    (aWriter)->WriteSentinel(1173948231);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemWritableFileStreamProperties>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___streamParams = IPC::ReadParam<::mozilla::ipc::RandomAccessStreamParams>(aReader);
    if (!maybe___streamParams) {
        aReader->FatalError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemWritableFileStreamProperties'");
        return {};

    }
    auto& _streamParams = *maybe___streamParams;
    // Sentinel = 'streamParams'
    if ((!((aReader)->ReadSentinel(544015601)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'streamParams' (RandomAccessStreamParams) member of 'FileSystemWritableFileStreamProperties'");
        return {};
    }
    auto maybe___writableFileStream = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::dom::PFileSystemWritableFileStreamParent*, ::mozilla::dom::PFileSystemWritableFileStreamChild*>>>(aReader);
    if (!maybe___writableFileStream) {
        aReader->FatalError("Error deserializing 'writableFileStream' (NotNull<PFileSystemWritableFileStream>) member of 'FileSystemWritableFileStreamProperties'");
        return {};

    }
    auto& _writableFileStream = *maybe___writableFileStream;
    // Sentinel = 'writableFileStream'
    if ((!((aReader)->ReadSentinel(1173948231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'writableFileStream' (NotNull<PFileSystemWritableFileStream>) member of 'FileSystemWritableFileStreamProperties'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_streamParams),
            std::move(_writableFileStream)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemGetWritableFileStreamResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemGetWritableFileStreamResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TFileSystemWritableFileStreamProperties:
        {
            (ptr_FileSystemWritableFileStreamProperties())->~FileSystemWritableFileStreamProperties__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(FileSystemWritableFileStreamProperties&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move(aOther));
    mType = TFileSystemWritableFileStreamProperties;
}

MOZ_IMPLICIT FileSystemGetWritableFileStreamResponse::FileSystemGetWritableFileStreamResponse(FileSystemGetWritableFileStreamResponse&& 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 TFileSystemWritableFileStreamProperties:
        {
            new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move((aOther).get_FileSystemWritableFileStreamProperties()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemGetWritableFileStreamResponse::operator=(FileSystemWritableFileStreamProperties&& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move(aRhs));
    mType = TFileSystemWritableFileStreamProperties;
    return (*(this));
}

auto FileSystemGetWritableFileStreamResponse::operator=(FileSystemGetWritableFileStreamResponse&& aRhs) -> FileSystemGetWritableFileStreamResponse&
{
    (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 TFileSystemWritableFileStreamProperties:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_FileSystemWritableFileStreamProperties()) FileSystemWritableFileStreamProperties(std::move((aRhs).get_FileSystemWritableFileStreamProperties()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TFileSystemWritableFileStreamProperties:
        {
            IPC::WriteParam(aWriter, std::move((aVar).get_FileSystemWritableFileStreamProperties()));
            // Sentinel = 'TFileSystemWritableFileStreamProperties'
            (aWriter)->WriteSentinel(880349101);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemGetWritableFileStreamResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemEntryPair>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).parentId());
    // Sentinel = 'parentId'
    (aWriter)->WriteSentinel(249430840);
    IPC::WriteParam(aWriter, (aVar).childId());
    // Sentinel = 'childId'
    (aWriter)->WriteSentinel(185270962);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemEntryPair>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___parentId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___parentId) {
        aReader->FatalError("Error deserializing 'parentId' (EntryId) member of 'FileSystemEntryPair'");
        return {};

    }
    auto& _parentId = *maybe___parentId;
    // Sentinel = 'parentId'
    if ((!((aReader)->ReadSentinel(249430840)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'parentId' (EntryId) member of 'FileSystemEntryPair'");
        return {};
    }
    auto maybe___childId = IPC::ReadParam<::mozilla::dom::fs::EntryId>(aReader);
    if (!maybe___childId) {
        aReader->FatalError("Error deserializing 'childId' (EntryId) member of 'FileSystemEntryPair'");
        return {};

    }
    auto& _childId = *maybe___childId;
    // Sentinel = 'childId'
    if ((!((aReader)->ReadSentinel(185270962)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'childId' (EntryId) member of 'FileSystemEntryPair'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_parentId),
            std::move(_childId)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemResolveRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___endpoints = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryPair>(aReader);
    if (!maybe___endpoints) {
        aReader->FatalError("Error deserializing 'endpoints' (FileSystemEntryPair) member of 'FileSystemResolveRequest'");
        return {};

    }
    auto& _endpoints = *maybe___endpoints;
    // Sentinel = 'endpoints'
    if ((!((aReader)->ReadSentinel(316015573)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'endpoints' (FileSystemEntryPair) member of 'FileSystemResolveRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_endpoints)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemPath>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___path = IPC::ReadParam<nsTArray<::mozilla::dom::fs::Name>>(aReader);
    if (!maybe___path) {
        aReader->FatalError("Error deserializing 'path' (Name[]) member of 'FileSystemPath'");
        return {};

    }
    auto& _path = *maybe___path;
    // Sentinel = 'path'
    if ((!((aReader)->ReadSentinel(70713774)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'path' (Name[]) member of 'FileSystemPath'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_path)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemResolveResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemResolveResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TMaybeFileSystemPath:
        {
            (ptr_MaybeFileSystemPath())->~MaybeFileSystemPath__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(const mozilla::Maybe<FileSystemPath>& aOther)
{
    new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(aOther);
    mType = TMaybeFileSystemPath;
}

MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(mozilla::Maybe<FileSystemPath>&& aOther)
{
    new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move(aOther));
    mType = TMaybeFileSystemPath;
}

MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(const FileSystemResolveResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TMaybeFileSystemPath:
        {
            new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>((aOther).get_MaybeFileSystemPath());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemResolveResponse::FileSystemResolveResponse(FileSystemResolveResponse&& 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 TMaybeFileSystemPath:
        {
            new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move((aOther).get_MaybeFileSystemPath()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemResolveResponse::operator=(const mozilla::Maybe<FileSystemPath>& aRhs) -> FileSystemResolveResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(aRhs);
    mType = TMaybeFileSystemPath;
    return (*(this));
}

auto FileSystemResolveResponse::operator=(mozilla::Maybe<FileSystemPath>&& aRhs) -> FileSystemResolveResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move(aRhs));
    mType = TMaybeFileSystemPath;
    return (*(this));
}

auto FileSystemResolveResponse::operator=(const FileSystemResolveResponse& aRhs) -> FileSystemResolveResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TMaybeFileSystemPath:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>((aRhs).get_MaybeFileSystemPath());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemResolveResponse::operator=(FileSystemResolveResponse&& aRhs) -> FileSystemResolveResponse&
{
    (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 TMaybeFileSystemPath:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_MaybeFileSystemPath()) mozilla::Maybe<FileSystemPath>(std::move((aRhs).get_MaybeFileSystemPath()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TMaybeFileSystemPath:
        {
            IPC::WriteParam(aWriter, (aVar).get_MaybeFileSystemPath());
            // Sentinel = 'TMaybeFileSystemPath'
            (aWriter)->WriteSentinel(1346766805);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemResolveResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).handle());
    // Sentinel = 'handle'
    (aWriter)->WriteSentinel(142344813);
    IPC::WriteParam(aWriter, (aVar).recursive());
    // Sentinel = 'recursive'
    (aWriter)->WriteSentinel(322438105);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemRemoveEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
    if (!maybe___handle) {
        aReader->FatalError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemRemoveEntryRequest'");
        return {};

    }
    auto& _handle = *maybe___handle;
    // Sentinel = 'handle'
    if ((!((aReader)->ReadSentinel(142344813)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemChildMetadata) member of 'FileSystemRemoveEntryRequest'");
        return {};
    }
    auto maybe___recursive = IPC::ReadParam<bool>(aReader);
    if (!maybe___recursive) {
        aReader->FatalError("Error deserializing 'recursive' (bool) member of 'FileSystemRemoveEntryRequest'");
        return {};

    }
    auto& _recursive = *maybe___recursive;
    // Sentinel = 'recursive'
    if ((!((aReader)->ReadSentinel(322438105)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'recursive' (bool) member of 'FileSystemRemoveEntryRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_handle),
            std::move(_recursive)};
    return result__;
}

} // namespace IPC

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

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

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

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

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

MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(const FileSystemRemoveEntryResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemRemoveEntryResponse::FileSystemRemoveEntryResponse(FileSystemRemoveEntryResponse&& 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 Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

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

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

auto FileSystemRemoveEntryResponse::operator=(const FileSystemRemoveEntryResponse& aRhs) -> FileSystemRemoveEntryResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case Tvoid_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aRhs).get_void_t());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemRemoveEntryResponse::operator=(FileSystemRemoveEntryResponse&& aRhs) -> FileSystemRemoveEntryResponse&
{
    (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 Tvoid_t:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aRhs).get_void_t()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

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

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).handle());
    // Sentinel = 'handle'
    (aWriter)->WriteSentinel(142344813);
    IPC::WriteParam(aWriter, (aVar).destHandle());
    // Sentinel = 'destHandle'
    (aWriter)->WriteSentinel(368641021);
}

auto ParamTraits<::mozilla::dom::fs::FileSystemMoveEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryMetadata>(aReader);
    if (!maybe___handle) {
        aReader->FatalError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemMoveEntryRequest'");
        return {};

    }
    auto& _handle = *maybe___handle;
    // Sentinel = 'handle'
    if ((!((aReader)->ReadSentinel(142344813)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemMoveEntryRequest'");
        return {};
    }
    auto maybe___destHandle = IPC::ReadParam<::mozilla::dom::fs::FileSystemChildMetadata>(aReader);
    if (!maybe___destHandle) {
        aReader->FatalError("Error deserializing 'destHandle' (FileSystemChildMetadata) member of 'FileSystemMoveEntryRequest'");
        return {};

    }
    auto& _destHandle = *maybe___destHandle;
    // Sentinel = 'destHandle'
    if ((!((aReader)->ReadSentinel(368641021)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'destHandle' (FileSystemChildMetadata) member of 'FileSystemMoveEntryRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_handle),
            std::move(_destHandle)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::fs::FileSystemRenameEntryRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___handle = IPC::ReadParam<::mozilla::dom::fs::FileSystemEntryMetadata>(aReader);
    if (!maybe___handle) {
        aReader->FatalError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemRenameEntryRequest'");
        return {};

    }
    auto& _handle = *maybe___handle;
    // Sentinel = 'handle'
    if ((!((aReader)->ReadSentinel(142344813)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (FileSystemEntryMetadata) member of 'FileSystemRenameEntryRequest'");
        return {};
    }
    auto maybe___name = IPC::ReadParam<::mozilla::dom::fs::Name>(aReader);
    if (!maybe___name) {
        aReader->FatalError("Error deserializing 'name' (Name) member of 'FileSystemRenameEntryRequest'");
        return {};

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (Name) member of 'FileSystemRenameEntryRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_handle),
            std::move(_name)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileSystemMoveEntryResponse|
//
namespace mozilla {
namespace dom {
namespace fs {
auto FileSystemMoveEntryResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TEntryId:
        {
            (ptr_EntryId())->~EntryId__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

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

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

MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(const EntryId& aOther)
{
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aOther);
    mType = TEntryId;
}

MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(EntryId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aOther));
    mType = TEntryId;
}

MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(const FileSystemMoveEntryResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TEntryId:
        {
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aOther).get_EntryId());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileSystemMoveEntryResponse::FileSystemMoveEntryResponse(FileSystemMoveEntryResponse&& 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 TEntryId:
        {
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aOther).get_EntryId()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto FileSystemMoveEntryResponse::operator=(const EntryId& aRhs) -> FileSystemMoveEntryResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(aRhs);
    mType = TEntryId;
    return (*(this));
}

auto FileSystemMoveEntryResponse::operator=(EntryId&& aRhs) -> FileSystemMoveEntryResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move(aRhs));
    mType = TEntryId;
    return (*(this));
}

auto FileSystemMoveEntryResponse::operator=(const FileSystemMoveEntryResponse& aRhs) -> FileSystemMoveEntryResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
            break;
        }
    case TEntryId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId((aRhs).get_EntryId());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileSystemMoveEntryResponse::operator=(FileSystemMoveEntryResponse&& aRhs) -> FileSystemMoveEntryResponse&
{
    (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 TEntryId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_EntryId()) EntryId(std::move((aRhs).get_EntryId()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace fs
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            IPC::WriteParam(aWriter, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aWriter)->WriteSentinel(313394133);
            return;
        }
    case union__::TEntryId:
        {
            IPC::WriteParam(aWriter, (aVar).get_EntryId());
            // Sentinel = 'TEntryId'
            (aWriter)->WriteSentinel(227279636);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union FileSystemMoveEntryResponse");
            return;
        }
    }
}

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

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

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

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

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

} // namespace IPC
