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


#include "mozilla/dom/WebAuthnIPCUtils.h"
#include "mozilla/dom/PWindowGlobalParent.h"
#include "mozilla/dom/PWindowGlobalChild.h"
#include "mozilla/dom/PWebAuthnTransaction.h"
#include "mozilla/dom/PWebAuthnTransactionParent.h"
#include "mozilla/dom/PWebAuthnTransactionChild.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 PWebAuthnTransaction {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParentDestInfo, aChildDestInfo, aParent, aChild);
}
nsresult
CreateEndpoints(
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_RequestRegister(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestRegister__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_RequestRegister(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_RequestRegister__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_RequestSign(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestSign__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_RequestSign(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_RequestSign__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_RequestIsUVPAA(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestIsUVPAA__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_RequestIsUVPAA(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_RequestIsUVPAA__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_RequestCancel(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestCancel__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}

} // namespace PWebAuthnTransaction
} // namespace dom
} // namespace mozilla

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnAuthenticatorSelection>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).residentKey());
    // Sentinel = 'residentKey'
    (aWriter)->WriteSentinel(459932808);
    IPC::WriteParam(aWriter, (aVar).userVerificationRequirement());
    // Sentinel = 'userVerificationRequirement'
    (aWriter)->WriteSentinel(2623474484);
    IPC::WriteParam(aWriter, (aVar).authenticatorAttachment());
    // Sentinel = 'authenticatorAttachment'
    (aWriter)->WriteSentinel(1921649029);
}

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

    }
    auto& _residentKey = *maybe___residentKey;
    // Sentinel = 'residentKey'
    if ((!((aReader)->ReadSentinel(459932808)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'residentKey' (nsString) member of 'WebAuthnAuthenticatorSelection'");
        return {};
    }
    auto maybe___userVerificationRequirement = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___userVerificationRequirement) {
        aReader->FatalError("Error deserializing 'userVerificationRequirement' (nsString) member of 'WebAuthnAuthenticatorSelection'");
        return {};

    }
    auto& _userVerificationRequirement = *maybe___userVerificationRequirement;
    // Sentinel = 'userVerificationRequirement'
    if ((!((aReader)->ReadSentinel(2623474484)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'userVerificationRequirement' (nsString) member of 'WebAuthnAuthenticatorSelection'");
        return {};
    }
    auto maybe___authenticatorAttachment = IPC::ReadParam<mozilla::Maybe<::nsString>>(aReader);
    if (!maybe___authenticatorAttachment) {
        aReader->FatalError("Error deserializing 'authenticatorAttachment' (nsString?) member of 'WebAuthnAuthenticatorSelection'");
        return {};

    }
    auto& _authenticatorAttachment = *maybe___authenticatorAttachment;
    // Sentinel = 'authenticatorAttachment'
    if ((!((aReader)->ReadSentinel(1921649029)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'authenticatorAttachment' (nsString?) member of 'WebAuthnAuthenticatorSelection'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_residentKey),
            std::move(_userVerificationRequirement),
            std::move(_authenticatorAttachment)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnScopedCredential>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).id());
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
    (aWriter)->WriteBytes((&((aVar).transports())), 1);
    // Sentinel = 'transports'
    (aWriter)->WriteSentinel(401409121);
}

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

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (uint8_t[]) member of 'WebAuthnScopedCredential'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_id),
            ::uint8_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->transports())), 1)))) {
        aReader->FatalError("Error bulk reading fields from uint8_t");
        return {};
    }
    // Sentinel = 'transports'
    if ((!((aReader)->ReadSentinel(401409121)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionCredProtect>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).policy());
    // Sentinel = 'policy'
    (aWriter)->WriteSentinel(150667921);
    IPC::WriteParam(aWriter, (aVar).required());
    // Sentinel = 'required'
    (aWriter)->WriteSentinel(259130210);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionCredProtect>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___policy = IPC::ReadParam<::mozilla::dom::CredentialProtectionPolicy>(aReader);
    if (!maybe___policy) {
        aReader->FatalError("Error deserializing 'policy' (CredentialProtectionPolicy) member of 'WebAuthnExtensionCredProtect'");
        return {};

    }
    auto& _policy = *maybe___policy;
    // Sentinel = 'policy'
    if ((!((aReader)->ReadSentinel(150667921)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'policy' (CredentialProtectionPolicy) member of 'WebAuthnExtensionCredProtect'");
        return {};
    }
    auto maybe___required = IPC::ReadParam<bool>(aReader);
    if (!maybe___required) {
        aReader->FatalError("Error deserializing 'required' (bool) member of 'WebAuthnExtensionCredProtect'");
        return {};

    }
    auto& _required = *maybe___required;
    // Sentinel = 'required'
    if ((!((aReader)->ReadSentinel(259130210)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'required' (bool) member of 'WebAuthnExtensionCredProtect'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_policy),
            std::move(_required)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _credProps = *maybe___credProps;
    // Sentinel = 'credProps'
    if ((!((aReader)->ReadSentinel(304546739)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'credProps' (bool) member of 'WebAuthnExtensionCredProps'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_credProps)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _hmacCreateSecret = *maybe___hmacCreateSecret;
    // Sentinel = 'hmacCreateSecret'
    if ((!((aReader)->ReadSentinel(890963540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hmacCreateSecret' (bool) member of 'WebAuthnExtensionHmacSecret'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_hmacCreateSecret)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionLargeBlob>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).flag());
    // Sentinel = 'flag'
    (aWriter)->WriteSentinel(67699099);
    IPC::WriteParam(aWriter, (aVar).write());
    // Sentinel = 'write'
    (aWriter)->WriteSentinel(111673900);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionLargeBlob>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___flag = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
    if (!maybe___flag) {
        aReader->FatalError("Error deserializing 'flag' (bool?) member of 'WebAuthnExtensionLargeBlob'");
        return {};

    }
    auto& _flag = *maybe___flag;
    // Sentinel = 'flag'
    if ((!((aReader)->ReadSentinel(67699099)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'flag' (bool?) member of 'WebAuthnExtensionLargeBlob'");
        return {};
    }
    auto maybe___write = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___write) {
        aReader->FatalError("Error deserializing 'write' (uint8_t[]) member of 'WebAuthnExtensionLargeBlob'");
        return {};

    }
    auto& _write = *maybe___write;
    // Sentinel = 'write'
    if ((!((aReader)->ReadSentinel(111673900)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'write' (uint8_t[]) member of 'WebAuthnExtensionLargeBlob'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_flag),
            std::move(_write)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _minPinLength = *maybe___minPinLength;
    // Sentinel = 'minPinLength'
    if ((!((aReader)->ReadSentinel(521077966)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'minPinLength' (bool) member of 'WebAuthnExtensionMinPinLength'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_minPinLength)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrf>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).eval());
    // Sentinel = 'eval'
    (aWriter)->WriteSentinel(69730729);
    IPC::WriteParam(aWriter, (aVar).evalByCredentialMaybe());
    // Sentinel = 'evalByCredentialMaybe'
    (aWriter)->WriteSentinel(1528039501);
    IPC::WriteParam(aWriter, (aVar).evalByCredential());
    // Sentinel = 'evalByCredential'
    (aWriter)->WriteSentinel(899679839);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrf>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___eval = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::WebAuthnExtensionPrfValues>>(aReader);
    if (!maybe___eval) {
        aReader->FatalError("Error deserializing 'eval' (WebAuthnExtensionPrfValues?) member of 'WebAuthnExtensionPrf'");
        return {};

    }
    auto& _eval = *maybe___eval;
    // Sentinel = 'eval'
    if ((!((aReader)->ReadSentinel(69730729)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'eval' (WebAuthnExtensionPrfValues?) member of 'WebAuthnExtensionPrf'");
        return {};
    }
    auto maybe___evalByCredentialMaybe = IPC::ReadParam<bool>(aReader);
    if (!maybe___evalByCredentialMaybe) {
        aReader->FatalError("Error deserializing 'evalByCredentialMaybe' (bool) member of 'WebAuthnExtensionPrf'");
        return {};

    }
    auto& _evalByCredentialMaybe = *maybe___evalByCredentialMaybe;
    // Sentinel = 'evalByCredentialMaybe'
    if ((!((aReader)->ReadSentinel(1528039501)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'evalByCredentialMaybe' (bool) member of 'WebAuthnExtensionPrf'");
        return {};
    }
    auto maybe___evalByCredential = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry>>(aReader);
    if (!maybe___evalByCredential) {
        aReader->FatalError("Error deserializing 'evalByCredential' (WebAuthnExtensionPrfEvalByCredentialEntry[]) member of 'WebAuthnExtensionPrf'");
        return {};

    }
    auto& _evalByCredential = *maybe___evalByCredential;
    // Sentinel = 'evalByCredential'
    if ((!((aReader)->ReadSentinel(899679839)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'evalByCredential' (WebAuthnExtensionPrfEvalByCredentialEntry[]) member of 'WebAuthnExtensionPrf'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_eval),
            std::move(_evalByCredentialMaybe),
            std::move(_evalByCredential)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrfValues>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).first());
    // Sentinel = 'first'
    (aWriter)->WriteSentinel(106365481);
    IPC::WriteParam(aWriter, (aVar).secondMaybe());
    // Sentinel = 'secondMaybe'
    (aWriter)->WriteSentinel(450102379);
    IPC::WriteParam(aWriter, (aVar).second());
    // Sentinel = 'second'
    (aWriter)->WriteSentinel(147456637);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrfValues>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___first = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___first) {
        aReader->FatalError("Error deserializing 'first' (uint8_t[]) member of 'WebAuthnExtensionPrfValues'");
        return {};

    }
    auto& _first = *maybe___first;
    // Sentinel = 'first'
    if ((!((aReader)->ReadSentinel(106365481)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'first' (uint8_t[]) member of 'WebAuthnExtensionPrfValues'");
        return {};
    }
    auto maybe___secondMaybe = IPC::ReadParam<bool>(aReader);
    if (!maybe___secondMaybe) {
        aReader->FatalError("Error deserializing 'secondMaybe' (bool) member of 'WebAuthnExtensionPrfValues'");
        return {};

    }
    auto& _secondMaybe = *maybe___secondMaybe;
    // Sentinel = 'secondMaybe'
    if ((!((aReader)->ReadSentinel(450102379)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'secondMaybe' (bool) member of 'WebAuthnExtensionPrfValues'");
        return {};
    }
    auto maybe___second = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___second) {
        aReader->FatalError("Error deserializing 'second' (uint8_t[]) member of 'WebAuthnExtensionPrfValues'");
        return {};

    }
    auto& _second = *maybe___second;
    // Sentinel = 'second'
    if ((!((aReader)->ReadSentinel(147456637)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'second' (uint8_t[]) member of 'WebAuthnExtensionPrfValues'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_first),
            std::move(_secondMaybe),
            std::move(_second)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).credentialId());
    // Sentinel = 'credentialId'
    (aWriter)->WriteSentinel(532219081);
    IPC::WriteParam(aWriter, (aVar).eval());
    // Sentinel = 'eval'
    (aWriter)->WriteSentinel(69730729);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___credentialId = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___credentialId) {
        aReader->FatalError("Error deserializing 'credentialId' (uint8_t[]) member of 'WebAuthnExtensionPrfEvalByCredentialEntry'");
        return {};

    }
    auto& _credentialId = *maybe___credentialId;
    // Sentinel = 'credentialId'
    if ((!((aReader)->ReadSentinel(532219081)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'credentialId' (uint8_t[]) member of 'WebAuthnExtensionPrfEvalByCredentialEntry'");
        return {};
    }
    auto maybe___eval = IPC::ReadParam<::mozilla::dom::WebAuthnExtensionPrfValues>(aReader);
    if (!maybe___eval) {
        aReader->FatalError("Error deserializing 'eval' (WebAuthnExtensionPrfValues) member of 'WebAuthnExtensionPrfEvalByCredentialEntry'");
        return {};

    }
    auto& _eval = *maybe___eval;
    // Sentinel = 'eval'
    if ((!((aReader)->ReadSentinel(69730729)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'eval' (WebAuthnExtensionPrfValues) member of 'WebAuthnExtensionPrfEvalByCredentialEntry'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_credentialId),
            std::move(_eval)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnExtension|
//
namespace mozilla {
namespace dom {
auto WebAuthnExtension::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TWebAuthnExtensionCredProtect:
        {
            (ptr_WebAuthnExtensionCredProtect())->~WebAuthnExtensionCredProtect__tdef();
            break;
        }
    case TWebAuthnExtensionCredProps:
        {
            (ptr_WebAuthnExtensionCredProps())->~WebAuthnExtensionCredProps__tdef();
            break;
        }
    case TWebAuthnExtensionHmacSecret:
        {
            (ptr_WebAuthnExtensionHmacSecret())->~WebAuthnExtensionHmacSecret__tdef();
            break;
        }
    case TWebAuthnExtensionLargeBlob:
        {
            (ptr_WebAuthnExtensionLargeBlob())->~WebAuthnExtensionLargeBlob__tdef();
            break;
        }
    case TWebAuthnExtensionMinPinLength:
        {
            (ptr_WebAuthnExtensionMinPinLength())->~WebAuthnExtensionMinPinLength__tdef();
            break;
        }
    case TWebAuthnExtensionPrf:
        {
            (ptr_WebAuthnExtensionPrf())->~WebAuthnExtensionPrf__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionCredProtect& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(aOther);
    mType = TWebAuthnExtensionCredProtect;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionCredProtect&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(std::move(aOther));
    mType = TWebAuthnExtensionCredProtect;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionCredProps& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(aOther);
    mType = TWebAuthnExtensionCredProps;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionCredProps&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(std::move(aOther));
    mType = TWebAuthnExtensionCredProps;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionHmacSecret& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(aOther);
    mType = TWebAuthnExtensionHmacSecret;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionHmacSecret&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(std::move(aOther));
    mType = TWebAuthnExtensionHmacSecret;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionLargeBlob& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(aOther);
    mType = TWebAuthnExtensionLargeBlob;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionLargeBlob&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(std::move(aOther));
    mType = TWebAuthnExtensionLargeBlob;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionMinPinLength& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(aOther);
    mType = TWebAuthnExtensionMinPinLength;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionMinPinLength&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(std::move(aOther));
    mType = TWebAuthnExtensionMinPinLength;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionPrf& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(aOther);
    mType = TWebAuthnExtensionPrf;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionPrf&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(std::move(aOther));
    mType = TWebAuthnExtensionPrf;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtension& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnExtensionCredProtect:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect((aOther).get_WebAuthnExtensionCredProtect());
            break;
        }
    case TWebAuthnExtensionCredProps:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps((aOther).get_WebAuthnExtensionCredProps());
            break;
        }
    case TWebAuthnExtensionHmacSecret:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret((aOther).get_WebAuthnExtensionHmacSecret());
            break;
        }
    case TWebAuthnExtensionLargeBlob:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob((aOther).get_WebAuthnExtensionLargeBlob());
            break;
        }
    case TWebAuthnExtensionMinPinLength:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength((aOther).get_WebAuthnExtensionMinPinLength());
            break;
        }
    case TWebAuthnExtensionPrf:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf((aOther).get_WebAuthnExtensionPrf());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtension&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnExtensionCredProtect:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(std::move((aOther).get_WebAuthnExtensionCredProtect()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionCredProps:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(std::move((aOther).get_WebAuthnExtensionCredProps()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionHmacSecret:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(std::move((aOther).get_WebAuthnExtensionHmacSecret()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionLargeBlob:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(std::move((aOther).get_WebAuthnExtensionLargeBlob()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionMinPinLength:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(std::move((aOther).get_WebAuthnExtensionMinPinLength()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionPrf:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(std::move((aOther).get_WebAuthnExtensionPrf()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnExtension::operator=(const WebAuthnExtensionCredProtect& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(aRhs);
    mType = TWebAuthnExtensionCredProtect;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionCredProtect&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(std::move(aRhs));
    mType = TWebAuthnExtensionCredProtect;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtensionCredProps& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(aRhs);
    mType = TWebAuthnExtensionCredProps;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionCredProps&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(std::move(aRhs));
    mType = TWebAuthnExtensionCredProps;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtensionHmacSecret& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(aRhs);
    mType = TWebAuthnExtensionHmacSecret;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionHmacSecret&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(std::move(aRhs));
    mType = TWebAuthnExtensionHmacSecret;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtensionLargeBlob& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(aRhs);
    mType = TWebAuthnExtensionLargeBlob;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionLargeBlob&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(std::move(aRhs));
    mType = TWebAuthnExtensionLargeBlob;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtensionMinPinLength& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(aRhs);
    mType = TWebAuthnExtensionMinPinLength;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionMinPinLength&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(std::move(aRhs));
    mType = TWebAuthnExtensionMinPinLength;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtensionPrf& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(aRhs);
    mType = TWebAuthnExtensionPrf;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionPrf&& aRhs) -> WebAuthnExtension&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(std::move(aRhs));
    mType = TWebAuthnExtensionPrf;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtension& aRhs) -> WebAuthnExtension&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionCredProtect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect((aRhs).get_WebAuthnExtensionCredProtect());
            break;
        }
    case TWebAuthnExtensionCredProps:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps((aRhs).get_WebAuthnExtensionCredProps());
            break;
        }
    case TWebAuthnExtensionHmacSecret:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret((aRhs).get_WebAuthnExtensionHmacSecret());
            break;
        }
    case TWebAuthnExtensionLargeBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob((aRhs).get_WebAuthnExtensionLargeBlob());
            break;
        }
    case TWebAuthnExtensionMinPinLength:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength((aRhs).get_WebAuthnExtensionMinPinLength());
            break;
        }
    case TWebAuthnExtensionPrf:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf((aRhs).get_WebAuthnExtensionPrf());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtension&& aRhs) -> WebAuthnExtension&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionCredProtect:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProtect()) WebAuthnExtensionCredProtect(std::move((aRhs).get_WebAuthnExtensionCredProtect()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionCredProps:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionCredProps()) WebAuthnExtensionCredProps(std::move((aRhs).get_WebAuthnExtensionCredProps()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionHmacSecret:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionHmacSecret()) WebAuthnExtensionHmacSecret(std::move((aRhs).get_WebAuthnExtensionHmacSecret()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionLargeBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionLargeBlob()) WebAuthnExtensionLargeBlob(std::move((aRhs).get_WebAuthnExtensionLargeBlob()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionMinPinLength:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionMinPinLength()) WebAuthnExtensionMinPinLength(std::move((aRhs).get_WebAuthnExtensionMinPinLength()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionPrf:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionPrf()) WebAuthnExtensionPrf(std::move((aRhs).get_WebAuthnExtensionPrf()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnExtensionCredProtect:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionCredProtect());
            // Sentinel = 'TWebAuthnExtensionCredProtect'
            (aWriter)->WriteSentinel(2852391823);
            return;
        }
    case union__::TWebAuthnExtensionCredProps:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionCredProps());
            // Sentinel = 'TWebAuthnExtensionCredProps'
            (aWriter)->WriteSentinel(2472544962);
            return;
        }
    case union__::TWebAuthnExtensionHmacSecret:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionHmacSecret());
            // Sentinel = 'TWebAuthnExtensionHmacSecret'
            (aWriter)->WriteSentinel(2650737423);
            return;
        }
    case union__::TWebAuthnExtensionLargeBlob:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionLargeBlob());
            // Sentinel = 'TWebAuthnExtensionLargeBlob'
            (aWriter)->WriteSentinel(2468547226);
            return;
        }
    case union__::TWebAuthnExtensionMinPinLength:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionMinPinLength());
            // Sentinel = 'TWebAuthnExtensionMinPinLength'
            (aWriter)->WriteSentinel(3044346845);
            return;
        }
    case union__::TWebAuthnExtensionPrf:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionPrf());
            // Sentinel = 'TWebAuthnExtensionPrf'
            (aWriter)->WriteSentinel(1501300824);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union WebAuthnExtension");
            return;
        }
    }
}

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

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

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

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

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

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _AppId = *maybe___AppId;
    // Sentinel = 'AppId'
    if ((!((aReader)->ReadSentinel(89129423)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AppId' (bool) member of 'WebAuthnExtensionResultAppId'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_AppId)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _rk = *maybe___rk;
    // Sentinel = 'rk'
    if ((!((aReader)->ReadSentinel(22085854)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'rk' (bool) member of 'WebAuthnExtensionResultCredProps'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_rk)};
    return result__;
}

} // namespace IPC

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

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

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

    }
    auto& _hmacCreateSecret = *maybe___hmacCreateSecret;
    // Sentinel = 'hmacCreateSecret'
    if ((!((aReader)->ReadSentinel(890963540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hmacCreateSecret' (bool) member of 'WebAuthnExtensionResultHmacSecret'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_hmacCreateSecret)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionResultLargeBlob>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).flag());
    // Sentinel = 'flag'
    (aWriter)->WriteSentinel(67699099);
    IPC::WriteParam(aWriter, (aVar).blob());
    // Sentinel = 'blob'
    (aWriter)->WriteSentinel(68157856);
    IPC::WriteParam(aWriter, (aVar).written());
    // Sentinel = 'written'
    (aWriter)->WriteSentinel(207946510);
}

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

    }
    auto& _flag = *maybe___flag;
    // Sentinel = 'flag'
    if ((!((aReader)->ReadSentinel(67699099)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'flag' (bool) member of 'WebAuthnExtensionResultLargeBlob'");
        return {};
    }
    auto maybe___blob = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___blob) {
        aReader->FatalError("Error deserializing 'blob' (uint8_t[]) member of 'WebAuthnExtensionResultLargeBlob'");
        return {};

    }
    auto& _blob = *maybe___blob;
    // Sentinel = 'blob'
    if ((!((aReader)->ReadSentinel(68157856)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'blob' (uint8_t[]) member of 'WebAuthnExtensionResultLargeBlob'");
        return {};
    }
    auto maybe___written = IPC::ReadParam<bool>(aReader);
    if (!maybe___written) {
        aReader->FatalError("Error deserializing 'written' (bool) member of 'WebAuthnExtensionResultLargeBlob'");
        return {};

    }
    auto& _written = *maybe___written;
    // Sentinel = 'written'
    if ((!((aReader)->ReadSentinel(207946510)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'written' (bool) member of 'WebAuthnExtensionResultLargeBlob'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_flag),
            std::move(_blob),
            std::move(_written)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnExtensionResultPrf>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).enabled());
    // Sentinel = 'enabled'
    (aWriter)->WriteSentinel(188547788);
    IPC::WriteParam(aWriter, (aVar).results());
    // Sentinel = 'results'
    (aWriter)->WriteSentinel(204800787);
}

auto ParamTraits<::mozilla::dom::WebAuthnExtensionResultPrf>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___enabled = IPC::ReadParam<mozilla::Maybe<bool>>(aReader);
    if (!maybe___enabled) {
        aReader->FatalError("Error deserializing 'enabled' (bool?) member of 'WebAuthnExtensionResultPrf'");
        return {};

    }
    auto& _enabled = *maybe___enabled;
    // Sentinel = 'enabled'
    if ((!((aReader)->ReadSentinel(188547788)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'enabled' (bool?) member of 'WebAuthnExtensionResultPrf'");
        return {};
    }
    auto maybe___results = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::WebAuthnExtensionPrfValues>>(aReader);
    if (!maybe___results) {
        aReader->FatalError("Error deserializing 'results' (WebAuthnExtensionPrfValues?) member of 'WebAuthnExtensionResultPrf'");
        return {};

    }
    auto& _results = *maybe___results;
    // Sentinel = 'results'
    if ((!((aReader)->ReadSentinel(204800787)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'results' (WebAuthnExtensionPrfValues?) member of 'WebAuthnExtensionResultPrf'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_enabled),
            std::move(_results)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnExtensionResult|
//
namespace mozilla {
namespace dom {
auto WebAuthnExtensionResult::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TWebAuthnExtensionResultAppId:
        {
            (ptr_WebAuthnExtensionResultAppId())->~WebAuthnExtensionResultAppId__tdef();
            break;
        }
    case TWebAuthnExtensionResultCredProps:
        {
            (ptr_WebAuthnExtensionResultCredProps())->~WebAuthnExtensionResultCredProps__tdef();
            break;
        }
    case TWebAuthnExtensionResultHmacSecret:
        {
            (ptr_WebAuthnExtensionResultHmacSecret())->~WebAuthnExtensionResultHmacSecret__tdef();
            break;
        }
    case TWebAuthnExtensionResultLargeBlob:
        {
            (ptr_WebAuthnExtensionResultLargeBlob())->~WebAuthnExtensionResultLargeBlob__tdef();
            break;
        }
    case TWebAuthnExtensionResultPrf:
        {
            (ptr_WebAuthnExtensionResultPrf())->~WebAuthnExtensionResultPrf__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultAppId& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(aOther);
    mType = TWebAuthnExtensionResultAppId;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultAppId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move(aOther));
    mType = TWebAuthnExtensionResultAppId;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultCredProps& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(aOther);
    mType = TWebAuthnExtensionResultCredProps;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultCredProps&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(std::move(aOther));
    mType = TWebAuthnExtensionResultCredProps;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultHmacSecret& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(aOther);
    mType = TWebAuthnExtensionResultHmacSecret;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultHmacSecret&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(std::move(aOther));
    mType = TWebAuthnExtensionResultHmacSecret;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultLargeBlob& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(aOther);
    mType = TWebAuthnExtensionResultLargeBlob;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultLargeBlob&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(std::move(aOther));
    mType = TWebAuthnExtensionResultLargeBlob;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultPrf& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(aOther);
    mType = TWebAuthnExtensionResultPrf;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultPrf&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(std::move(aOther));
    mType = TWebAuthnExtensionResultPrf;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnExtensionResultAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId((aOther).get_WebAuthnExtensionResultAppId());
            break;
        }
    case TWebAuthnExtensionResultCredProps:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps((aOther).get_WebAuthnExtensionResultCredProps());
            break;
        }
    case TWebAuthnExtensionResultHmacSecret:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret((aOther).get_WebAuthnExtensionResultHmacSecret());
            break;
        }
    case TWebAuthnExtensionResultLargeBlob:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob((aOther).get_WebAuthnExtensionResultLargeBlob());
            break;
        }
    case TWebAuthnExtensionResultPrf:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf((aOther).get_WebAuthnExtensionResultPrf());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResult&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move((aOther).get_WebAuthnExtensionResultAppId()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultCredProps:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(std::move((aOther).get_WebAuthnExtensionResultCredProps()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultHmacSecret:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(std::move((aOther).get_WebAuthnExtensionResultHmacSecret()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultLargeBlob:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(std::move((aOther).get_WebAuthnExtensionResultLargeBlob()));
            (aOther).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultPrf:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(std::move((aOther).get_WebAuthnExtensionResultPrf()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultAppId& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(aRhs);
    mType = TWebAuthnExtensionResultAppId;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultAppId&& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move(aRhs));
    mType = TWebAuthnExtensionResultAppId;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultCredProps& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(aRhs);
    mType = TWebAuthnExtensionResultCredProps;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultCredProps&& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(std::move(aRhs));
    mType = TWebAuthnExtensionResultCredProps;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultHmacSecret& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(aRhs);
    mType = TWebAuthnExtensionResultHmacSecret;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultHmacSecret&& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(std::move(aRhs));
    mType = TWebAuthnExtensionResultHmacSecret;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultLargeBlob& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(aRhs);
    mType = TWebAuthnExtensionResultLargeBlob;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultLargeBlob&& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(std::move(aRhs));
    mType = TWebAuthnExtensionResultLargeBlob;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultPrf& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(aRhs);
    mType = TWebAuthnExtensionResultPrf;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultPrf&& aRhs) -> WebAuthnExtensionResult&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(std::move(aRhs));
    mType = TWebAuthnExtensionResultPrf;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResult& aRhs) -> WebAuthnExtensionResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId((aRhs).get_WebAuthnExtensionResultAppId());
            break;
        }
    case TWebAuthnExtensionResultCredProps:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps((aRhs).get_WebAuthnExtensionResultCredProps());
            break;
        }
    case TWebAuthnExtensionResultHmacSecret:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret((aRhs).get_WebAuthnExtensionResultHmacSecret());
            break;
        }
    case TWebAuthnExtensionResultLargeBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob((aRhs).get_WebAuthnExtensionResultLargeBlob());
            break;
        }
    case TWebAuthnExtensionResultPrf:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf((aRhs).get_WebAuthnExtensionResultPrf());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResult&& aRhs) -> WebAuthnExtensionResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move((aRhs).get_WebAuthnExtensionResultAppId()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultCredProps:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultCredProps()) WebAuthnExtensionResultCredProps(std::move((aRhs).get_WebAuthnExtensionResultCredProps()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultHmacSecret:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultHmacSecret()) WebAuthnExtensionResultHmacSecret(std::move((aRhs).get_WebAuthnExtensionResultHmacSecret()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultLargeBlob:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultLargeBlob()) WebAuthnExtensionResultLargeBlob(std::move((aRhs).get_WebAuthnExtensionResultLargeBlob()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TWebAuthnExtensionResultPrf:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultPrf()) WebAuthnExtensionResultPrf(std::move((aRhs).get_WebAuthnExtensionResultPrf()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnExtensionResultAppId:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionResultAppId());
            // Sentinel = 'TWebAuthnExtensionResultAppId'
            (aWriter)->WriteSentinel(2867071869);
            return;
        }
    case union__::TWebAuthnExtensionResultCredProps:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionResultCredProps());
            // Sentinel = 'TWebAuthnExtensionResultCredProps'
            (aWriter)->WriteSentinel(3713207617);
            return;
        }
    case union__::TWebAuthnExtensionResultHmacSecret:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionResultHmacSecret());
            // Sentinel = 'TWebAuthnExtensionResultHmacSecret'
            (aWriter)->WriteSentinel(3933277582);
            return;
        }
    case union__::TWebAuthnExtensionResultLargeBlob:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionResultLargeBlob());
            // Sentinel = 'TWebAuthnExtensionResultLargeBlob'
            (aWriter)->WriteSentinel(3709209881);
            return;
        }
    case union__::TWebAuthnExtensionResultPrf:
        {
            IPC::WriteParam(aWriter, (aVar).get_WebAuthnExtensionResultPrf());
            // Sentinel = 'TWebAuthnExtensionResultPrf'
            (aWriter)->WriteSentinel(2490698455);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union WebAuthnExtensionResult");
            return;
        }
    }
}

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

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

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

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

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

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

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

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

} // namespace IPC

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

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

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

    }
    auto& _Name = *maybe___Name;
    // Sentinel = 'Name'
    if ((!((aReader)->ReadSentinel(60686722)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Name' (nsString) member of 'WebAuthnMakeCredentialRpInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_Name)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnMakeCredentialUserInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).Id());
    // Sentinel = 'Id'
    (aWriter)->WriteSentinel(16253102);
    IPC::WriteParam(aWriter, (aVar).Name());
    // Sentinel = 'Name'
    (aWriter)->WriteSentinel(60686722);
    IPC::WriteParam(aWriter, (aVar).DisplayName());
    // Sentinel = 'DisplayName'
    (aWriter)->WriteSentinel(432866392);
}

auto ParamTraits<::mozilla::dom::WebAuthnMakeCredentialUserInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___Id = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___Id) {
        aReader->FatalError("Error deserializing 'Id' (uint8_t[]) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};

    }
    auto& _Id = *maybe___Id;
    // Sentinel = 'Id'
    if ((!((aReader)->ReadSentinel(16253102)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Id' (uint8_t[]) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};
    }
    auto maybe___Name = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___Name) {
        aReader->FatalError("Error deserializing 'Name' (nsString) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};

    }
    auto& _Name = *maybe___Name;
    // Sentinel = 'Name'
    if ((!((aReader)->ReadSentinel(60686722)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Name' (nsString) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};
    }
    auto maybe___DisplayName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___DisplayName) {
        aReader->FatalError("Error deserializing 'DisplayName' (nsString) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};

    }
    auto& _DisplayName = *maybe___DisplayName;
    // Sentinel = 'DisplayName'
    if ((!((aReader)->ReadSentinel(432866392)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'DisplayName' (nsString) member of 'WebAuthnMakeCredentialUserInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_Id),
            std::move(_Name),
            std::move(_DisplayName)};
    return result__;
}

} // namespace IPC

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

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

auto ParamTraits<::mozilla::dom::CoseAlg>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___alg = IPC::ReadParam<long>(aReader);
    if (!maybe___alg) {
        aReader->FatalError("Error deserializing 'alg' (long) member of 'CoseAlg'");
        return {};

    }
    auto& _alg = *maybe___alg;
    // Sentinel = 'alg'
    if ((!((aReader)->ReadSentinel(40173877)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'alg' (long) member of 'CoseAlg'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_alg)};
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnMakeCredentialInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).RpId());
    // Sentinel = 'RpId'
    (aWriter)->WriteSentinel(59900272);
    IPC::WriteParam(aWriter, (aVar).Challenge());
    // Sentinel = 'Challenge'
    (aWriter)->WriteSentinel(285213572);
    IPC::WriteParam(aWriter, (aVar).ExcludeList());
    // Sentinel = 'ExcludeList'
    (aWriter)->WriteSentinel(433456231);
    IPC::WriteParam(aWriter, (aVar).Rp());
    // Sentinel = 'Rp'
    (aWriter)->WriteSentinel(18219203);
    IPC::WriteParam(aWriter, (aVar).User());
    // Sentinel = 'User'
    (aWriter)->WriteSentinel(65864096);
    IPC::WriteParam(aWriter, (aVar).coseAlgs());
    // Sentinel = 'coseAlgs'
    (aWriter)->WriteSentinel(240976690);
    IPC::WriteParam(aWriter, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aWriter)->WriteSentinel(376046641);
    IPC::WriteParam(aWriter, (aVar).AuthenticatorSelection());
    // Sentinel = 'AuthenticatorSelection'
    (aWriter)->WriteSentinel(1720125698);
    IPC::WriteParam(aWriter, (aVar).attestationConveyancePreference());
    // Sentinel = 'attestationConveyancePreference'
    (aWriter)->WriteSentinel(3454864571);
    IPC::WriteParam(aWriter, (aVar).Hints());
    // Sentinel = 'Hints'
    (aWriter)->WriteSentinel(95814151);
    (aWriter)->WriteBytes((&((aVar).TimeoutMS())), 4);
    // Sentinel = 'TimeoutMS'
    (aWriter)->WriteSentinel(300286856);
}

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

    }
    auto& _RpId = *maybe___RpId;
    // Sentinel = 'RpId'
    if ((!((aReader)->ReadSentinel(59900272)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RpId' (nsCString) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___Challenge = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___Challenge) {
        aReader->FatalError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _Challenge = *maybe___Challenge;
    // Sentinel = 'Challenge'
    if ((!((aReader)->ReadSentinel(285213572)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___ExcludeList = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnScopedCredential>>(aReader);
    if (!maybe___ExcludeList) {
        aReader->FatalError("Error deserializing 'ExcludeList' (WebAuthnScopedCredential[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _ExcludeList = *maybe___ExcludeList;
    // Sentinel = 'ExcludeList'
    if ((!((aReader)->ReadSentinel(433456231)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ExcludeList' (WebAuthnScopedCredential[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___Rp = IPC::ReadParam<::mozilla::dom::WebAuthnMakeCredentialRpInfo>(aReader);
    if (!maybe___Rp) {
        aReader->FatalError("Error deserializing 'Rp' (WebAuthnMakeCredentialRpInfo) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _Rp = *maybe___Rp;
    // Sentinel = 'Rp'
    if ((!((aReader)->ReadSentinel(18219203)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Rp' (WebAuthnMakeCredentialRpInfo) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___User = IPC::ReadParam<::mozilla::dom::WebAuthnMakeCredentialUserInfo>(aReader);
    if (!maybe___User) {
        aReader->FatalError("Error deserializing 'User' (WebAuthnMakeCredentialUserInfo) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _User = *maybe___User;
    // Sentinel = 'User'
    if ((!((aReader)->ReadSentinel(65864096)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'User' (WebAuthnMakeCredentialUserInfo) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___coseAlgs = IPC::ReadParam<nsTArray<::mozilla::dom::CoseAlg>>(aReader);
    if (!maybe___coseAlgs) {
        aReader->FatalError("Error deserializing 'coseAlgs' (CoseAlg[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _coseAlgs = *maybe___coseAlgs;
    // Sentinel = 'coseAlgs'
    if ((!((aReader)->ReadSentinel(240976690)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'coseAlgs' (CoseAlg[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___Extensions = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnExtension>>(aReader);
    if (!maybe___Extensions) {
        aReader->FatalError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _Extensions = *maybe___Extensions;
    // Sentinel = 'Extensions'
    if ((!((aReader)->ReadSentinel(376046641)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___AuthenticatorSelection = IPC::ReadParam<::mozilla::dom::WebAuthnAuthenticatorSelection>(aReader);
    if (!maybe___AuthenticatorSelection) {
        aReader->FatalError("Error deserializing 'AuthenticatorSelection' (WebAuthnAuthenticatorSelection) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _AuthenticatorSelection = *maybe___AuthenticatorSelection;
    // Sentinel = 'AuthenticatorSelection'
    if ((!((aReader)->ReadSentinel(1720125698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorSelection' (WebAuthnAuthenticatorSelection) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___attestationConveyancePreference = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___attestationConveyancePreference) {
        aReader->FatalError("Error deserializing 'attestationConveyancePreference' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _attestationConveyancePreference = *maybe___attestationConveyancePreference;
    // Sentinel = 'attestationConveyancePreference'
    if ((!((aReader)->ReadSentinel(3454864571)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'attestationConveyancePreference' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    auto maybe___Hints = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___Hints) {
        aReader->FatalError("Error deserializing 'Hints' (nsString[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};

    }
    auto& _Hints = *maybe___Hints;
    // Sentinel = 'Hints'
    if ((!((aReader)->ReadSentinel(95814151)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Hints' (nsString[]) member of 'WebAuthnMakeCredentialInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_RpId),
            std::move(_Challenge),
            ::uint32_t{0},
            std::move(_ExcludeList),
            std::move(_Rp),
            std::move(_User),
            std::move(_coseAlgs),
            std::move(_Extensions),
            std::move(_AuthenticatorSelection),
            std::move(_attestationConveyancePreference),
            std::move(_Hints)};
    if ((!((aReader)->ReadBytesInto((&((result__)->TimeoutMS())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'TimeoutMS'
    if ((!((aReader)->ReadSentinel(300286856)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnMakeCredentialResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aWriter)->WriteSentinel(659031316);
    IPC::WriteParam(aWriter, (aVar).AttestationObject());
    // Sentinel = 'AttestationObject'
    (aWriter)->WriteSentinel(1039009512);
    IPC::WriteParam(aWriter, (aVar).KeyHandle());
    // Sentinel = 'KeyHandle'
    (aWriter)->WriteSentinel(282657654);
    IPC::WriteParam(aWriter, (aVar).Transports());
    // Sentinel = 'Transports'
    (aWriter)->WriteSentinel(380437569);
    IPC::WriteParam(aWriter, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aWriter)->WriteSentinel(376046641);
    IPC::WriteParam(aWriter, (aVar).AuthenticatorAttachment());
    // Sentinel = 'AuthenticatorAttachment'
    (aWriter)->WriteSentinel(1873414501);
}

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

    }
    auto& _ClientDataJSON = *maybe___ClientDataJSON;
    // Sentinel = 'ClientDataJSON'
    if ((!((aReader)->ReadSentinel(659031316)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    auto maybe___AttestationObject = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___AttestationObject) {
        aReader->FatalError("Error deserializing 'AttestationObject' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return {};

    }
    auto& _AttestationObject = *maybe___AttestationObject;
    // Sentinel = 'AttestationObject'
    if ((!((aReader)->ReadSentinel(1039009512)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AttestationObject' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    auto maybe___KeyHandle = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___KeyHandle) {
        aReader->FatalError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return {};

    }
    auto& _KeyHandle = *maybe___KeyHandle;
    // Sentinel = 'KeyHandle'
    if ((!((aReader)->ReadSentinel(282657654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    auto maybe___Transports = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___Transports) {
        aReader->FatalError("Error deserializing 'Transports' (nsString[]) member of 'WebAuthnMakeCredentialResult'");
        return {};

    }
    auto& _Transports = *maybe___Transports;
    // Sentinel = 'Transports'
    if ((!((aReader)->ReadSentinel(380437569)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Transports' (nsString[]) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    auto maybe___Extensions = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnExtensionResult>>(aReader);
    if (!maybe___Extensions) {
        aReader->FatalError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnMakeCredentialResult'");
        return {};

    }
    auto& _Extensions = *maybe___Extensions;
    // Sentinel = 'Extensions'
    if ((!((aReader)->ReadSentinel(376046641)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    auto maybe___AuthenticatorAttachment = IPC::ReadParam<mozilla::Maybe<::nsString>>(aReader);
    if (!maybe___AuthenticatorAttachment) {
        aReader->FatalError("Error deserializing 'AuthenticatorAttachment' (nsString?) member of 'WebAuthnMakeCredentialResult'");
        return {};

    }
    auto& _AuthenticatorAttachment = *maybe___AuthenticatorAttachment;
    // Sentinel = 'AuthenticatorAttachment'
    if ((!((aReader)->ReadSentinel(1873414501)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorAttachment' (nsString?) member of 'WebAuthnMakeCredentialResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_ClientDataJSON),
            std::move(_AttestationObject),
            std::move(_KeyHandle),
            std::move(_Transports),
            std::move(_Extensions),
            std::move(_AuthenticatorAttachment)};
    return result__;
}

} // namespace IPC

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

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

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

MOZ_IMPLICIT WebAuthnMakeCredentialResponse::WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult(aOther);
    mType = TWebAuthnMakeCredentialResult;
}

MOZ_IMPLICIT WebAuthnMakeCredentialResponse::WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult(std::move(aOther));
    mType = TWebAuthnMakeCredentialResult;
}

MOZ_IMPLICIT WebAuthnMakeCredentialResponse::WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TWebAuthnMakeCredentialResult:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult((aOther).get_WebAuthnMakeCredentialResult());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnMakeCredentialResponse::WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResponse&& 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 TWebAuthnMakeCredentialResult:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult(std::move((aOther).get_WebAuthnMakeCredentialResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto WebAuthnMakeCredentialResponse::operator=(const WebAuthnMakeCredentialResult& aRhs) -> WebAuthnMakeCredentialResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult(aRhs);
    mType = TWebAuthnMakeCredentialResult;
    return (*(this));
}

auto WebAuthnMakeCredentialResponse::operator=(WebAuthnMakeCredentialResult&& aRhs) -> WebAuthnMakeCredentialResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialResult()) WebAuthnMakeCredentialResult(std::move(aRhs));
    mType = TWebAuthnMakeCredentialResult;
    return (*(this));
}

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

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

} // namespace dom
} // namespace mozilla

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

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

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

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

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

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

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

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnGetAssertionInfo>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).RpId());
    // Sentinel = 'RpId'
    (aWriter)->WriteSentinel(59900272);
    IPC::WriteParam(aWriter, (aVar).AppId());
    // Sentinel = 'AppId'
    (aWriter)->WriteSentinel(89129423);
    IPC::WriteParam(aWriter, (aVar).Challenge());
    // Sentinel = 'Challenge'
    (aWriter)->WriteSentinel(285213572);
    IPC::WriteParam(aWriter, (aVar).AllowList());
    // Sentinel = 'AllowList'
    (aWriter)->WriteSentinel(290980764);
    IPC::WriteParam(aWriter, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aWriter)->WriteSentinel(376046641);
    IPC::WriteParam(aWriter, (aVar).userVerificationRequirement());
    // Sentinel = 'userVerificationRequirement'
    (aWriter)->WriteSentinel(2623474484);
    IPC::WriteParam(aWriter, (aVar).ConditionallyMediated());
    // Sentinel = 'ConditionallyMediated'
    (aWriter)->WriteSentinel(1556154487);
    IPC::WriteParam(aWriter, (aVar).Hints());
    // Sentinel = 'Hints'
    (aWriter)->WriteSentinel(95814151);
    (aWriter)->WriteBytes((&((aVar).TimeoutMS())), 4);
    // Sentinel = 'TimeoutMS'
    (aWriter)->WriteSentinel(300286856);
}

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

    }
    auto& _RpId = *maybe___RpId;
    // Sentinel = 'RpId'
    if ((!((aReader)->ReadSentinel(59900272)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RpId' (nsCString) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___AppId = IPC::ReadParam<mozilla::Maybe<::nsCString>>(aReader);
    if (!maybe___AppId) {
        aReader->FatalError("Error deserializing 'AppId' (nsCString?) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _AppId = *maybe___AppId;
    // Sentinel = 'AppId'
    if ((!((aReader)->ReadSentinel(89129423)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AppId' (nsCString?) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___Challenge = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___Challenge) {
        aReader->FatalError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _Challenge = *maybe___Challenge;
    // Sentinel = 'Challenge'
    if ((!((aReader)->ReadSentinel(285213572)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___AllowList = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnScopedCredential>>(aReader);
    if (!maybe___AllowList) {
        aReader->FatalError("Error deserializing 'AllowList' (WebAuthnScopedCredential[]) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _AllowList = *maybe___AllowList;
    // Sentinel = 'AllowList'
    if ((!((aReader)->ReadSentinel(290980764)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AllowList' (WebAuthnScopedCredential[]) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___Extensions = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnExtension>>(aReader);
    if (!maybe___Extensions) {
        aReader->FatalError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _Extensions = *maybe___Extensions;
    // Sentinel = 'Extensions'
    if ((!((aReader)->ReadSentinel(376046641)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___userVerificationRequirement = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___userVerificationRequirement) {
        aReader->FatalError("Error deserializing 'userVerificationRequirement' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _userVerificationRequirement = *maybe___userVerificationRequirement;
    // Sentinel = 'userVerificationRequirement'
    if ((!((aReader)->ReadSentinel(2623474484)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'userVerificationRequirement' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___ConditionallyMediated = IPC::ReadParam<bool>(aReader);
    if (!maybe___ConditionallyMediated) {
        aReader->FatalError("Error deserializing 'ConditionallyMediated' (bool) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _ConditionallyMediated = *maybe___ConditionallyMediated;
    // Sentinel = 'ConditionallyMediated'
    if ((!((aReader)->ReadSentinel(1556154487)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ConditionallyMediated' (bool) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    auto maybe___Hints = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___Hints) {
        aReader->FatalError("Error deserializing 'Hints' (nsString[]) member of 'WebAuthnGetAssertionInfo'");
        return {};

    }
    auto& _Hints = *maybe___Hints;
    // Sentinel = 'Hints'
    if ((!((aReader)->ReadSentinel(95814151)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Hints' (nsString[]) member of 'WebAuthnGetAssertionInfo'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_RpId),
            std::move(_AppId),
            std::move(_Challenge),
            ::uint32_t{0},
            std::move(_AllowList),
            std::move(_Extensions),
            std::move(_userVerificationRequirement),
            std::move(_ConditionallyMediated),
            std::move(_Hints)};
    if ((!((aReader)->ReadBytesInto((&((result__)->TimeoutMS())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'TimeoutMS'
    if ((!((aReader)->ReadSentinel(300286856)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

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

namespace IPC {
auto ParamTraits<::mozilla::dom::WebAuthnGetAssertionResult>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aWriter)->WriteSentinel(659031316);
    IPC::WriteParam(aWriter, (aVar).KeyHandle());
    // Sentinel = 'KeyHandle'
    (aWriter)->WriteSentinel(282657654);
    IPC::WriteParam(aWriter, (aVar).Signature());
    // Sentinel = 'Signature'
    (aWriter)->WriteSentinel(301859763);
    IPC::WriteParam(aWriter, (aVar).AuthenticatorData());
    // Sentinel = 'AuthenticatorData'
    (aWriter)->WriteSentinel(1032586966);
    IPC::WriteParam(aWriter, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aWriter)->WriteSentinel(376046641);
    IPC::WriteParam(aWriter, (aVar).UserHandle());
    // Sentinel = 'UserHandle'
    (aWriter)->WriteSentinel(358810604);
    IPC::WriteParam(aWriter, (aVar).AuthenticatorAttachment());
    // Sentinel = 'AuthenticatorAttachment'
    (aWriter)->WriteSentinel(1873414501);
}

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

    }
    auto& _ClientDataJSON = *maybe___ClientDataJSON;
    // Sentinel = 'ClientDataJSON'
    if ((!((aReader)->ReadSentinel(659031316)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___KeyHandle = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___KeyHandle) {
        aReader->FatalError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _KeyHandle = *maybe___KeyHandle;
    // Sentinel = 'KeyHandle'
    if ((!((aReader)->ReadSentinel(282657654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___Signature = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___Signature) {
        aReader->FatalError("Error deserializing 'Signature' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _Signature = *maybe___Signature;
    // Sentinel = 'Signature'
    if ((!((aReader)->ReadSentinel(301859763)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Signature' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___AuthenticatorData = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___AuthenticatorData) {
        aReader->FatalError("Error deserializing 'AuthenticatorData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _AuthenticatorData = *maybe___AuthenticatorData;
    // Sentinel = 'AuthenticatorData'
    if ((!((aReader)->ReadSentinel(1032586966)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___Extensions = IPC::ReadParam<nsTArray<::mozilla::dom::WebAuthnExtensionResult>>(aReader);
    if (!maybe___Extensions) {
        aReader->FatalError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _Extensions = *maybe___Extensions;
    // Sentinel = 'Extensions'
    if ((!((aReader)->ReadSentinel(376046641)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___UserHandle = IPC::ReadParam<nsTArray<::uint8_t>>(aReader);
    if (!maybe___UserHandle) {
        aReader->FatalError("Error deserializing 'UserHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _UserHandle = *maybe___UserHandle;
    // Sentinel = 'UserHandle'
    if ((!((aReader)->ReadSentinel(358810604)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'UserHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    auto maybe___AuthenticatorAttachment = IPC::ReadParam<mozilla::Maybe<::nsString>>(aReader);
    if (!maybe___AuthenticatorAttachment) {
        aReader->FatalError("Error deserializing 'AuthenticatorAttachment' (nsString?) member of 'WebAuthnGetAssertionResult'");
        return {};

    }
    auto& _AuthenticatorAttachment = *maybe___AuthenticatorAttachment;
    // Sentinel = 'AuthenticatorAttachment'
    if ((!((aReader)->ReadSentinel(1873414501)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorAttachment' (nsString?) member of 'WebAuthnGetAssertionResult'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_ClientDataJSON),
            std::move(_KeyHandle),
            std::move(_Signature),
            std::move(_AuthenticatorData),
            std::move(_Extensions),
            std::move(_UserHandle),
            std::move(_AuthenticatorAttachment)};
    return result__;
}

} // namespace IPC

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

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

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

MOZ_IMPLICIT WebAuthnGetAssertionResponse::WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResult& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult(aOther);
    mType = TWebAuthnGetAssertionResult;
}

MOZ_IMPLICIT WebAuthnGetAssertionResponse::WebAuthnGetAssertionResponse(WebAuthnGetAssertionResult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult(std::move(aOther));
    mType = TWebAuthnGetAssertionResult;
}

MOZ_IMPLICIT WebAuthnGetAssertionResponse::WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TWebAuthnGetAssertionResult:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult((aOther).get_WebAuthnGetAssertionResult());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnGetAssertionResponse::WebAuthnGetAssertionResponse(WebAuthnGetAssertionResponse&& 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 TWebAuthnGetAssertionResult:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult(std::move((aOther).get_WebAuthnGetAssertionResult()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto WebAuthnGetAssertionResponse::operator=(const WebAuthnGetAssertionResult& aRhs) -> WebAuthnGetAssertionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult(aRhs);
    mType = TWebAuthnGetAssertionResult;
    return (*(this));
}

auto WebAuthnGetAssertionResponse::operator=(WebAuthnGetAssertionResult&& aRhs) -> WebAuthnGetAssertionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionResult()) WebAuthnGetAssertionResult(std::move(aRhs));
    mType = TWebAuthnGetAssertionResult;
    return (*(this));
}

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

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

} // namespace dom
} // namespace mozilla

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

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

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

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

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

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

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

} // namespace IPC
