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

#ifndef PWebAuthnTransaction_h
#define PWebAuthnTransaction_h

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

// Headers for typedefs
#include "mozilla/dom/WebAuthenticationBinding.h"
#include "mozilla/ipc/IPDLStructMember.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnAuthenticatorSelection|
//
namespace mozilla {
namespace dom {
class WebAuthnAuthenticatorSelection final
{
private:
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnAuthenticatorSelection(
            const nsString& _residentKey,
            const nsString& _userVerificationRequirement,
            const mozilla::Maybe<nsString>& _authenticatorAttachment) :
        residentKey_(_residentKey),
        userVerificationRequirement_(_userVerificationRequirement),
        authenticatorAttachment_(_authenticatorAttachment)
    {
    }

    MOZ_IMPLICIT WebAuthnAuthenticatorSelection(
            nsString&& _residentKey,
            nsString&& _userVerificationRequirement,
            mozilla::Maybe<nsString>&& _authenticatorAttachment) :
        residentKey_(std::move(_residentKey)),
        userVerificationRequirement_(std::move(_userVerificationRequirement)),
        authenticatorAttachment_(std::move(_authenticatorAttachment))
    {
    }

    nsString&
    residentKey()
    {
        return residentKey_;
    }
    const nsString&
    residentKey() const
    {
        return residentKey_;
    }

    nsString&
    userVerificationRequirement()
    {
        return userVerificationRequirement_;
    }
    const nsString&
    userVerificationRequirement() const
    {
        return userVerificationRequirement_;
    }

    mozilla::Maybe<nsString>&
    authenticatorAttachment()
    {
        return authenticatorAttachment_;
    }
    const mozilla::Maybe<nsString>&
    authenticatorAttachment() const
    {
        return authenticatorAttachment_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> residentKey_;
    ::mozilla::ipc::IPDLStructMember<nsString> userVerificationRequirement_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> authenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnScopedCredential|
//
namespace mozilla {
namespace dom {
class WebAuthnScopedCredential final
{
private:
    typedef ::uint8_t uint8_t;

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

    MOZ_IMPLICIT WebAuthnScopedCredential(
            const nsTArray<uint8_t>& _id,
            const uint8_t& _transports) :
        id_(_id),
        transports_(_transports)
    {
    }

    MOZ_IMPLICIT WebAuthnScopedCredential(
            nsTArray<uint8_t>&& _id,
            uint8_t&& _transports) :
        id_(std::move(_id)),
        transports_(std::move(_transports))
    {
    }

    nsTArray<uint8_t>&
    id()
    {
        return id_;
    }
    const nsTArray<uint8_t>&
    id() const
    {
        return id_;
    }

    uint8_t&
    transports()
    {
        return transports_;
    }
    const uint8_t&
    transports() const
    {
        return transports_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> id_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> transports_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionCredProtect|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionCredProtect final
{
private:
    typedef ::mozilla::dom::CredentialProtectionPolicy CredentialProtectionPolicy;

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

    MOZ_IMPLICIT WebAuthnExtensionCredProtect(
            const CredentialProtectionPolicy& _policy,
            const bool& _required) :
        policy_(_policy),
        required_(_required)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionCredProtect(
            CredentialProtectionPolicy&& _policy,
            bool&& _required) :
        policy_(std::move(_policy)),
        required_(std::move(_required))
    {
    }

    CredentialProtectionPolicy&
    policy()
    {
        return policy_;
    }
    const CredentialProtectionPolicy&
    policy() const
    {
        return policy_;
    }

    bool&
    required()
    {
        return required_;
    }
    const bool&
    required() const
    {
        return required_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CredentialProtectionPolicy> policy_;
    ::mozilla::ipc::IPDLStructMember<bool> required_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionCredProps(const bool& _credProps) :
        credProps_(_credProps)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionCredProps(bool&& _credProps) :
        credProps_(std::move(_credProps))
    {
    }

    bool&
    credProps()
    {
        return credProps_;
    }
    const bool&
    credProps() const
    {
        return credProps_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> credProps_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionHmacSecret(const bool& _hmacCreateSecret) :
        hmacCreateSecret_(_hmacCreateSecret)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionHmacSecret(bool&& _hmacCreateSecret) :
        hmacCreateSecret_(std::move(_hmacCreateSecret))
    {
    }

    bool&
    hmacCreateSecret()
    {
        return hmacCreateSecret_;
    }
    const bool&
    hmacCreateSecret() const
    {
        return hmacCreateSecret_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> hmacCreateSecret_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionLargeBlob|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionLargeBlob final
{
private:
    typedef ::uint8_t uint8_t;

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

    MOZ_IMPLICIT WebAuthnExtensionLargeBlob(
            const mozilla::Maybe<bool>& _flag,
            const nsTArray<uint8_t>& _write) :
        flag_(_flag),
        write_(_write)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionLargeBlob(
            mozilla::Maybe<bool>&& _flag,
            nsTArray<uint8_t>&& _write) :
        flag_(std::move(_flag)),
        write_(std::move(_write))
    {
    }

    mozilla::Maybe<bool>&
    flag()
    {
        return flag_;
    }
    const mozilla::Maybe<bool>&
    flag() const
    {
        return flag_;
    }

    nsTArray<uint8_t>&
    write()
    {
        return write_;
    }
    const nsTArray<uint8_t>&
    write() const
    {
        return write_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> flag_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> write_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionMinPinLength(const bool& _minPinLength) :
        minPinLength_(_minPinLength)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionMinPinLength(bool&& _minPinLength) :
        minPinLength_(std::move(_minPinLength))
    {
    }

    bool&
    minPinLength()
    {
        return minPinLength_;
    }
    const bool&
    minPinLength() const
    {
        return minPinLength_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> minPinLength_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrfValues|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrfValues final
{
private:
    typedef ::uint8_t uint8_t;

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

    MOZ_IMPLICIT WebAuthnExtensionPrfValues(
            const nsTArray<uint8_t>& _first,
            const bool& _secondMaybe,
            const nsTArray<uint8_t>& _second) :
        first_(_first),
        secondMaybe_(_secondMaybe),
        second_(_second)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionPrfValues(
            nsTArray<uint8_t>&& _first,
            bool&& _secondMaybe,
            nsTArray<uint8_t>&& _second) :
        first_(std::move(_first)),
        secondMaybe_(std::move(_secondMaybe)),
        second_(std::move(_second))
    {
    }

    nsTArray<uint8_t>&
    first()
    {
        return first_;
    }
    const nsTArray<uint8_t>&
    first() const
    {
        return first_;
    }

    bool&
    secondMaybe()
    {
        return secondMaybe_;
    }
    const bool&
    secondMaybe() const
    {
        return secondMaybe_;
    }

    nsTArray<uint8_t>&
    second()
    {
        return second_;
    }
    const nsTArray<uint8_t>&
    second() const
    {
        return second_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> first_;
    ::mozilla::ipc::IPDLStructMember<bool> secondMaybe_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> second_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrfEvalByCredentialEntry|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrfEvalByCredentialEntry final
{
private:
    typedef ::uint8_t uint8_t;
    typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;

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

    MOZ_IMPLICIT WebAuthnExtensionPrfEvalByCredentialEntry(
            const nsTArray<uint8_t>& _credentialId,
            const WebAuthnExtensionPrfValues& _eval) :
        credentialId_(_credentialId),
        eval_(_eval)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionPrfEvalByCredentialEntry(
            nsTArray<uint8_t>&& _credentialId,
            WebAuthnExtensionPrfValues&& _eval) :
        credentialId_(std::move(_credentialId)),
        eval_(std::move(_eval))
    {
    }

    nsTArray<uint8_t>&
    credentialId()
    {
        return credentialId_;
    }
    const nsTArray<uint8_t>&
    credentialId() const
    {
        return credentialId_;
    }

    WebAuthnExtensionPrfValues&
    eval()
    {
        return eval_;
    }
    const WebAuthnExtensionPrfValues&
    eval() const
    {
        return eval_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> credentialId_;
    ::mozilla::ipc::IPDLStructMember<WebAuthnExtensionPrfValues> eval_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrf|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrf final
{
private:
    typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;
    typedef ::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry WebAuthnExtensionPrfEvalByCredentialEntry;

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

    MOZ_IMPLICIT WebAuthnExtensionPrf(
            const mozilla::Maybe<WebAuthnExtensionPrfValues>& _eval,
            const bool& _evalByCredentialMaybe,
            const nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>& _evalByCredential) :
        eval_(_eval),
        evalByCredentialMaybe_(_evalByCredentialMaybe),
        evalByCredential_(_evalByCredential)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionPrf(
            mozilla::Maybe<WebAuthnExtensionPrfValues>&& _eval,
            bool&& _evalByCredentialMaybe,
            nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&& _evalByCredential) :
        eval_(std::move(_eval)),
        evalByCredentialMaybe_(std::move(_evalByCredentialMaybe)),
        evalByCredential_(std::move(_evalByCredential))
    {
    }

    mozilla::Maybe<WebAuthnExtensionPrfValues>&
    eval()
    {
        return eval_;
    }
    const mozilla::Maybe<WebAuthnExtensionPrfValues>&
    eval() const
    {
        return eval_;
    }

    bool&
    evalByCredentialMaybe()
    {
        return evalByCredentialMaybe_;
    }
    const bool&
    evalByCredentialMaybe() const
    {
        return evalByCredentialMaybe_;
    }

    nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&
    evalByCredential()
    {
        return evalByCredential_;
    }
    const nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&
    evalByCredential() const
    {
        return evalByCredential_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<WebAuthnExtensionPrfValues>> eval_;
    ::mozilla::ipc::IPDLStructMember<bool> evalByCredentialMaybe_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionPrfEvalByCredentialEntry>> evalByCredential_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnExtension|
//
namespace mozilla {
namespace dom {
class WebAuthnExtension final
{
public:
    enum Type {
        T__None,
        TWebAuthnExtensionCredProtect = 1,
        TWebAuthnExtensionCredProps,
        TWebAuthnExtensionHmacSecret,
        TWebAuthnExtensionLargeBlob,
        TWebAuthnExtensionMinPinLength,
        TWebAuthnExtensionPrf,
        T__Last = TWebAuthnExtensionPrf
    };

private:
    typedef ::mozilla::dom::WebAuthnExtensionCredProtect WebAuthnExtensionCredProtect;
    typedef ::mozilla::dom::WebAuthnExtensionCredProps WebAuthnExtensionCredProps;
    typedef ::mozilla::dom::WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret;
    typedef ::mozilla::dom::WebAuthnExtensionLargeBlob WebAuthnExtensionLargeBlob;
    typedef ::mozilla::dom::WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength;
    typedef ::mozilla::dom::WebAuthnExtensionPrf WebAuthnExtensionPrf;
    typedef WebAuthnExtensionCredProtect WebAuthnExtensionCredProtect__tdef;
    typedef WebAuthnExtensionCredProps WebAuthnExtensionCredProps__tdef;
    typedef WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret__tdef;
    typedef WebAuthnExtensionLargeBlob WebAuthnExtensionLargeBlob__tdef;
    typedef WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength__tdef;
    typedef WebAuthnExtensionPrf WebAuthnExtensionPrf__tdef;

    WebAuthnExtensionCredProtect*
    ptr_WebAuthnExtensionCredProtect()
    {
        return (&(mVWebAuthnExtensionCredProtect));
    }
    const WebAuthnExtensionCredProtect*
    constptr_WebAuthnExtensionCredProtect() const
    {
        return (&(mVWebAuthnExtensionCredProtect));
    }
    WebAuthnExtensionCredProps*
    ptr_WebAuthnExtensionCredProps()
    {
        return (&(mVWebAuthnExtensionCredProps));
    }
    const WebAuthnExtensionCredProps*
    constptr_WebAuthnExtensionCredProps() const
    {
        return (&(mVWebAuthnExtensionCredProps));
    }
    WebAuthnExtensionHmacSecret*
    ptr_WebAuthnExtensionHmacSecret()
    {
        return (&(mVWebAuthnExtensionHmacSecret));
    }
    const WebAuthnExtensionHmacSecret*
    constptr_WebAuthnExtensionHmacSecret() const
    {
        return (&(mVWebAuthnExtensionHmacSecret));
    }
    WebAuthnExtensionLargeBlob*
    ptr_WebAuthnExtensionLargeBlob()
    {
        return (&(mVWebAuthnExtensionLargeBlob));
    }
    const WebAuthnExtensionLargeBlob*
    constptr_WebAuthnExtensionLargeBlob() const
    {
        return (&(mVWebAuthnExtensionLargeBlob));
    }
    WebAuthnExtensionMinPinLength*
    ptr_WebAuthnExtensionMinPinLength()
    {
        return (&(mVWebAuthnExtensionMinPinLength));
    }
    const WebAuthnExtensionMinPinLength*
    constptr_WebAuthnExtensionMinPinLength() const
    {
        return (&(mVWebAuthnExtensionMinPinLength));
    }
    WebAuthnExtensionPrf*
    ptr_WebAuthnExtensionPrf()
    {
        return (&(mVWebAuthnExtensionPrf));
    }
    const WebAuthnExtensionPrf*
    constptr_WebAuthnExtensionPrf() const
    {
        return (&(mVWebAuthnExtensionPrf));
    }

    void
    MaybeDestroy();

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

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

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionCredProtect& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionCredProtect&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionCredProps& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionCredProps&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionHmacSecret& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionHmacSecret&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionLargeBlob& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionLargeBlob&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionMinPinLength& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionMinPinLength&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionPrf& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionPrf&& aOther);

    MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtension& aOther);

    MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtension&& aOther);

    ~WebAuthnExtension();

    Type
    type() const
    {
        return mType;
    }

    WebAuthnExtension&
    operator=(const WebAuthnExtensionCredProtect& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionCredProtect&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtensionCredProps& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionCredProps&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtensionHmacSecret& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionHmacSecret&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtensionLargeBlob& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionLargeBlob&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtensionMinPinLength& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionMinPinLength&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtensionPrf& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtensionPrf&& aRhs);

    WebAuthnExtension&
    operator=(const WebAuthnExtension& aRhs);

    WebAuthnExtension&
    operator=(WebAuthnExtension&& aRhs);

    WebAuthnExtensionCredProtect&
    get_WebAuthnExtensionCredProtect()
    {
        AssertSanity(TWebAuthnExtensionCredProtect);
        return (*(ptr_WebAuthnExtensionCredProtect()));
    }
    const WebAuthnExtensionCredProtect&
    get_WebAuthnExtensionCredProtect() const
    {
        AssertSanity(TWebAuthnExtensionCredProtect);
        return (*(constptr_WebAuthnExtensionCredProtect()));
    }
    operator WebAuthnExtensionCredProtect&()
    {
        return get_WebAuthnExtensionCredProtect();
    }
    operator const WebAuthnExtensionCredProtect&() const
    {
        return get_WebAuthnExtensionCredProtect();
    }

    WebAuthnExtensionCredProps&
    get_WebAuthnExtensionCredProps()
    {
        AssertSanity(TWebAuthnExtensionCredProps);
        return (*(ptr_WebAuthnExtensionCredProps()));
    }
    const WebAuthnExtensionCredProps&
    get_WebAuthnExtensionCredProps() const
    {
        AssertSanity(TWebAuthnExtensionCredProps);
        return (*(constptr_WebAuthnExtensionCredProps()));
    }
    operator WebAuthnExtensionCredProps&()
    {
        return get_WebAuthnExtensionCredProps();
    }
    operator const WebAuthnExtensionCredProps&() const
    {
        return get_WebAuthnExtensionCredProps();
    }

    WebAuthnExtensionHmacSecret&
    get_WebAuthnExtensionHmacSecret()
    {
        AssertSanity(TWebAuthnExtensionHmacSecret);
        return (*(ptr_WebAuthnExtensionHmacSecret()));
    }
    const WebAuthnExtensionHmacSecret&
    get_WebAuthnExtensionHmacSecret() const
    {
        AssertSanity(TWebAuthnExtensionHmacSecret);
        return (*(constptr_WebAuthnExtensionHmacSecret()));
    }
    operator WebAuthnExtensionHmacSecret&()
    {
        return get_WebAuthnExtensionHmacSecret();
    }
    operator const WebAuthnExtensionHmacSecret&() const
    {
        return get_WebAuthnExtensionHmacSecret();
    }

    WebAuthnExtensionLargeBlob&
    get_WebAuthnExtensionLargeBlob()
    {
        AssertSanity(TWebAuthnExtensionLargeBlob);
        return (*(ptr_WebAuthnExtensionLargeBlob()));
    }
    const WebAuthnExtensionLargeBlob&
    get_WebAuthnExtensionLargeBlob() const
    {
        AssertSanity(TWebAuthnExtensionLargeBlob);
        return (*(constptr_WebAuthnExtensionLargeBlob()));
    }
    operator WebAuthnExtensionLargeBlob&()
    {
        return get_WebAuthnExtensionLargeBlob();
    }
    operator const WebAuthnExtensionLargeBlob&() const
    {
        return get_WebAuthnExtensionLargeBlob();
    }

    WebAuthnExtensionMinPinLength&
    get_WebAuthnExtensionMinPinLength()
    {
        AssertSanity(TWebAuthnExtensionMinPinLength);
        return (*(ptr_WebAuthnExtensionMinPinLength()));
    }
    const WebAuthnExtensionMinPinLength&
    get_WebAuthnExtensionMinPinLength() const
    {
        AssertSanity(TWebAuthnExtensionMinPinLength);
        return (*(constptr_WebAuthnExtensionMinPinLength()));
    }
    operator WebAuthnExtensionMinPinLength&()
    {
        return get_WebAuthnExtensionMinPinLength();
    }
    operator const WebAuthnExtensionMinPinLength&() const
    {
        return get_WebAuthnExtensionMinPinLength();
    }

    WebAuthnExtensionPrf&
    get_WebAuthnExtensionPrf()
    {
        AssertSanity(TWebAuthnExtensionPrf);
        return (*(ptr_WebAuthnExtensionPrf()));
    }
    const WebAuthnExtensionPrf&
    get_WebAuthnExtensionPrf() const
    {
        AssertSanity(TWebAuthnExtensionPrf);
        return (*(constptr_WebAuthnExtensionPrf()));
    }
    operator WebAuthnExtensionPrf&()
    {
        return get_WebAuthnExtensionPrf();
    }
    operator const WebAuthnExtensionPrf&() const
    {
        return get_WebAuthnExtensionPrf();
    }

private:
    union {
        WebAuthnExtensionCredProtect mVWebAuthnExtensionCredProtect;
        WebAuthnExtensionCredProps mVWebAuthnExtensionCredProps;
        WebAuthnExtensionHmacSecret mVWebAuthnExtensionHmacSecret;
        WebAuthnExtensionLargeBlob mVWebAuthnExtensionLargeBlob;
        WebAuthnExtensionMinPinLength mVWebAuthnExtensionMinPinLength;
        WebAuthnExtensionPrf mVWebAuthnExtensionPrf;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionResultAppId(const bool& _AppId) :
        AppId_(_AppId)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionResultAppId(bool&& _AppId) :
        AppId_(std::move(_AppId))
    {
    }

    bool&
    AppId()
    {
        return AppId_;
    }
    const bool&
    AppId() const
    {
        return AppId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> AppId_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionResultCredProps(const bool& _rk) :
        rk_(_rk)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionResultCredProps(bool&& _rk) :
        rk_(std::move(_rk))
    {
    }

    bool&
    rk()
    {
        return rk_;
    }
    const bool&
    rk() const
    {
        return rk_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> rk_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT WebAuthnExtensionResultHmacSecret(const bool& _hmacCreateSecret) :
        hmacCreateSecret_(_hmacCreateSecret)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionResultHmacSecret(bool&& _hmacCreateSecret) :
        hmacCreateSecret_(std::move(_hmacCreateSecret))
    {
    }

    bool&
    hmacCreateSecret()
    {
        return hmacCreateSecret_;
    }
    const bool&
    hmacCreateSecret() const
    {
        return hmacCreateSecret_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> hmacCreateSecret_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultLargeBlob|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultLargeBlob final
{
private:
    typedef ::uint8_t uint8_t;

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

    MOZ_IMPLICIT WebAuthnExtensionResultLargeBlob(
            const bool& _flag,
            const nsTArray<uint8_t>& _blob,
            const bool& _written) :
        flag_(_flag),
        blob_(_blob),
        written_(_written)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionResultLargeBlob(
            bool&& _flag,
            nsTArray<uint8_t>&& _blob,
            bool&& _written) :
        flag_(std::move(_flag)),
        blob_(std::move(_blob)),
        written_(std::move(_written))
    {
    }

    bool&
    flag()
    {
        return flag_;
    }
    const bool&
    flag() const
    {
        return flag_;
    }

    nsTArray<uint8_t>&
    blob()
    {
        return blob_;
    }
    const nsTArray<uint8_t>&
    blob() const
    {
        return blob_;
    }

    bool&
    written()
    {
        return written_;
    }
    const bool&
    written() const
    {
        return written_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> flag_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> blob_;
    ::mozilla::ipc::IPDLStructMember<bool> written_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultPrf|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultPrf final
{
private:
    typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;

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

    MOZ_IMPLICIT WebAuthnExtensionResultPrf(
            const mozilla::Maybe<bool>& _enabled,
            const mozilla::Maybe<WebAuthnExtensionPrfValues>& _results) :
        enabled_(_enabled),
        results_(_results)
    {
    }

    MOZ_IMPLICIT WebAuthnExtensionResultPrf(
            mozilla::Maybe<bool>&& _enabled,
            mozilla::Maybe<WebAuthnExtensionPrfValues>&& _results) :
        enabled_(std::move(_enabled)),
        results_(std::move(_results))
    {
    }

    mozilla::Maybe<bool>&
    enabled()
    {
        return enabled_;
    }
    const mozilla::Maybe<bool>&
    enabled() const
    {
        return enabled_;
    }

    mozilla::Maybe<WebAuthnExtensionPrfValues>&
    results()
    {
        return results_;
    }
    const mozilla::Maybe<WebAuthnExtensionPrfValues>&
    results() const
    {
        return results_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> enabled_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<WebAuthnExtensionPrfValues>> results_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnExtensionResult|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResult final
{
public:
    enum Type {
        T__None,
        TWebAuthnExtensionResultAppId = 1,
        TWebAuthnExtensionResultCredProps,
        TWebAuthnExtensionResultHmacSecret,
        TWebAuthnExtensionResultLargeBlob,
        TWebAuthnExtensionResultPrf,
        T__Last = TWebAuthnExtensionResultPrf
    };

private:
    typedef ::mozilla::dom::WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId;
    typedef ::mozilla::dom::WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps;
    typedef ::mozilla::dom::WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret;
    typedef ::mozilla::dom::WebAuthnExtensionResultLargeBlob WebAuthnExtensionResultLargeBlob;
    typedef ::mozilla::dom::WebAuthnExtensionResultPrf WebAuthnExtensionResultPrf;
    typedef WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId__tdef;
    typedef WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps__tdef;
    typedef WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret__tdef;
    typedef WebAuthnExtensionResultLargeBlob WebAuthnExtensionResultLargeBlob__tdef;
    typedef WebAuthnExtensionResultPrf WebAuthnExtensionResultPrf__tdef;

    WebAuthnExtensionResultAppId*
    ptr_WebAuthnExtensionResultAppId()
    {
        return (&(mVWebAuthnExtensionResultAppId));
    }
    const WebAuthnExtensionResultAppId*
    constptr_WebAuthnExtensionResultAppId() const
    {
        return (&(mVWebAuthnExtensionResultAppId));
    }
    WebAuthnExtensionResultCredProps*
    ptr_WebAuthnExtensionResultCredProps()
    {
        return (&(mVWebAuthnExtensionResultCredProps));
    }
    const WebAuthnExtensionResultCredProps*
    constptr_WebAuthnExtensionResultCredProps() const
    {
        return (&(mVWebAuthnExtensionResultCredProps));
    }
    WebAuthnExtensionResultHmacSecret*
    ptr_WebAuthnExtensionResultHmacSecret()
    {
        return (&(mVWebAuthnExtensionResultHmacSecret));
    }
    const WebAuthnExtensionResultHmacSecret*
    constptr_WebAuthnExtensionResultHmacSecret() const
    {
        return (&(mVWebAuthnExtensionResultHmacSecret));
    }
    WebAuthnExtensionResultLargeBlob*
    ptr_WebAuthnExtensionResultLargeBlob()
    {
        return (&(mVWebAuthnExtensionResultLargeBlob));
    }
    const WebAuthnExtensionResultLargeBlob*
    constptr_WebAuthnExtensionResultLargeBlob() const
    {
        return (&(mVWebAuthnExtensionResultLargeBlob));
    }
    WebAuthnExtensionResultPrf*
    ptr_WebAuthnExtensionResultPrf()
    {
        return (&(mVWebAuthnExtensionResultPrf));
    }
    const WebAuthnExtensionResultPrf*
    constptr_WebAuthnExtensionResultPrf() const
    {
        return (&(mVWebAuthnExtensionResultPrf));
    }

    void
    MaybeDestroy();

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

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

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultAppId& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultAppId&& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultCredProps& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultCredProps&& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultHmacSecret& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultHmacSecret&& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultLargeBlob& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultLargeBlob&& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultPrf& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultPrf&& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResult& aOther);

    MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResult&& aOther);

    ~WebAuthnExtensionResult();

    Type
    type() const
    {
        return mType;
    }

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResultAppId& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResultAppId&& aRhs);

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResultCredProps& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResultCredProps&& aRhs);

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResultHmacSecret& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResultHmacSecret&& aRhs);

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResultLargeBlob& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResultLargeBlob&& aRhs);

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResultPrf& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResultPrf&& aRhs);

    WebAuthnExtensionResult&
    operator=(const WebAuthnExtensionResult& aRhs);

    WebAuthnExtensionResult&
    operator=(WebAuthnExtensionResult&& aRhs);

    WebAuthnExtensionResultAppId&
    get_WebAuthnExtensionResultAppId()
    {
        AssertSanity(TWebAuthnExtensionResultAppId);
        return (*(ptr_WebAuthnExtensionResultAppId()));
    }
    const WebAuthnExtensionResultAppId&
    get_WebAuthnExtensionResultAppId() const
    {
        AssertSanity(TWebAuthnExtensionResultAppId);
        return (*(constptr_WebAuthnExtensionResultAppId()));
    }
    operator WebAuthnExtensionResultAppId&()
    {
        return get_WebAuthnExtensionResultAppId();
    }
    operator const WebAuthnExtensionResultAppId&() const
    {
        return get_WebAuthnExtensionResultAppId();
    }

    WebAuthnExtensionResultCredProps&
    get_WebAuthnExtensionResultCredProps()
    {
        AssertSanity(TWebAuthnExtensionResultCredProps);
        return (*(ptr_WebAuthnExtensionResultCredProps()));
    }
    const WebAuthnExtensionResultCredProps&
    get_WebAuthnExtensionResultCredProps() const
    {
        AssertSanity(TWebAuthnExtensionResultCredProps);
        return (*(constptr_WebAuthnExtensionResultCredProps()));
    }
    operator WebAuthnExtensionResultCredProps&()
    {
        return get_WebAuthnExtensionResultCredProps();
    }
    operator const WebAuthnExtensionResultCredProps&() const
    {
        return get_WebAuthnExtensionResultCredProps();
    }

    WebAuthnExtensionResultHmacSecret&
    get_WebAuthnExtensionResultHmacSecret()
    {
        AssertSanity(TWebAuthnExtensionResultHmacSecret);
        return (*(ptr_WebAuthnExtensionResultHmacSecret()));
    }
    const WebAuthnExtensionResultHmacSecret&
    get_WebAuthnExtensionResultHmacSecret() const
    {
        AssertSanity(TWebAuthnExtensionResultHmacSecret);
        return (*(constptr_WebAuthnExtensionResultHmacSecret()));
    }
    operator WebAuthnExtensionResultHmacSecret&()
    {
        return get_WebAuthnExtensionResultHmacSecret();
    }
    operator const WebAuthnExtensionResultHmacSecret&() const
    {
        return get_WebAuthnExtensionResultHmacSecret();
    }

    WebAuthnExtensionResultLargeBlob&
    get_WebAuthnExtensionResultLargeBlob()
    {
        AssertSanity(TWebAuthnExtensionResultLargeBlob);
        return (*(ptr_WebAuthnExtensionResultLargeBlob()));
    }
    const WebAuthnExtensionResultLargeBlob&
    get_WebAuthnExtensionResultLargeBlob() const
    {
        AssertSanity(TWebAuthnExtensionResultLargeBlob);
        return (*(constptr_WebAuthnExtensionResultLargeBlob()));
    }
    operator WebAuthnExtensionResultLargeBlob&()
    {
        return get_WebAuthnExtensionResultLargeBlob();
    }
    operator const WebAuthnExtensionResultLargeBlob&() const
    {
        return get_WebAuthnExtensionResultLargeBlob();
    }

    WebAuthnExtensionResultPrf&
    get_WebAuthnExtensionResultPrf()
    {
        AssertSanity(TWebAuthnExtensionResultPrf);
        return (*(ptr_WebAuthnExtensionResultPrf()));
    }
    const WebAuthnExtensionResultPrf&
    get_WebAuthnExtensionResultPrf() const
    {
        AssertSanity(TWebAuthnExtensionResultPrf);
        return (*(constptr_WebAuthnExtensionResultPrf()));
    }
    operator WebAuthnExtensionResultPrf&()
    {
        return get_WebAuthnExtensionResultPrf();
    }
    operator const WebAuthnExtensionResultPrf&() const
    {
        return get_WebAuthnExtensionResultPrf();
    }

private:
    union {
        WebAuthnExtensionResultAppId mVWebAuthnExtensionResultAppId;
        WebAuthnExtensionResultCredProps mVWebAuthnExtensionResultCredProps;
        WebAuthnExtensionResultHmacSecret mVWebAuthnExtensionResultHmacSecret;
        WebAuthnExtensionResultLargeBlob mVWebAuthnExtensionResultLargeBlob;
        WebAuthnExtensionResultPrf mVWebAuthnExtensionResultPrf;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialRpInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialRpInfo final
{
private:
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnMakeCredentialRpInfo(const nsString& _Name) :
        Name_(_Name)
    {
    }

    MOZ_IMPLICIT WebAuthnMakeCredentialRpInfo(nsString&& _Name) :
        Name_(std::move(_Name))
    {
    }

    nsString&
    Name()
    {
        return Name_;
    }
    const nsString&
    Name() const
    {
        return Name_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> Name_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialUserInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialUserInfo final
{
private:
    typedef ::uint8_t uint8_t;
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnMakeCredentialUserInfo(
            const nsTArray<uint8_t>& _Id,
            const nsString& _Name,
            const nsString& _DisplayName) :
        Id_(_Id),
        Name_(_Name),
        DisplayName_(_DisplayName)
    {
    }

    MOZ_IMPLICIT WebAuthnMakeCredentialUserInfo(
            nsTArray<uint8_t>&& _Id,
            nsString&& _Name,
            nsString&& _DisplayName) :
        Id_(std::move(_Id)),
        Name_(std::move(_Name)),
        DisplayName_(std::move(_DisplayName))
    {
    }

    nsTArray<uint8_t>&
    Id()
    {
        return Id_;
    }
    const nsTArray<uint8_t>&
    Id() const
    {
        return Id_;
    }

    nsString&
    Name()
    {
        return Name_;
    }
    const nsString&
    Name() const
    {
        return Name_;
    }

    nsString&
    DisplayName()
    {
        return DisplayName_;
    }
    const nsString&
    DisplayName() const
    {
        return DisplayName_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Id_;
    ::mozilla::ipc::IPDLStructMember<nsString> Name_;
    ::mozilla::ipc::IPDLStructMember<nsString> DisplayName_;
};
} // namespace dom
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT CoseAlg(const long& _alg) :
        alg_(_alg)
    {
    }

    MOZ_IMPLICIT CoseAlg(long&& _alg) :
        alg_(std::move(_alg))
    {
    }

    long&
    alg()
    {
        return alg_;
    }
    const long&
    alg() const
    {
        return alg_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<long> alg_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialInfo final
{
private:
    typedef ::nsCString nsCString;
    typedef ::uint8_t uint8_t;
    typedef ::uint32_t uint32_t;
    typedef ::mozilla::dom::WebAuthnScopedCredential WebAuthnScopedCredential;
    typedef ::mozilla::dom::WebAuthnMakeCredentialRpInfo WebAuthnMakeCredentialRpInfo;
    typedef ::mozilla::dom::WebAuthnMakeCredentialUserInfo WebAuthnMakeCredentialUserInfo;
    typedef ::mozilla::dom::CoseAlg CoseAlg;
    typedef ::mozilla::dom::WebAuthnExtension WebAuthnExtension;
    typedef ::mozilla::dom::WebAuthnAuthenticatorSelection WebAuthnAuthenticatorSelection;
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnMakeCredentialInfo(
            const nsCString& _RpId,
            const nsTArray<uint8_t>& _Challenge,
            const uint32_t& _TimeoutMS,
            const nsTArray<WebAuthnScopedCredential>& _ExcludeList,
            const WebAuthnMakeCredentialRpInfo& _Rp,
            const WebAuthnMakeCredentialUserInfo& _User,
            const nsTArray<CoseAlg>& _coseAlgs,
            const nsTArray<WebAuthnExtension>& _Extensions,
            const WebAuthnAuthenticatorSelection& _AuthenticatorSelection,
            const nsString& _attestationConveyancePreference,
            const nsTArray<nsString>& _Hints) :
        RpId_(_RpId),
        Challenge_(_Challenge),
        ExcludeList_(_ExcludeList),
        Rp_(_Rp),
        User_(_User),
        coseAlgs_(_coseAlgs),
        Extensions_(_Extensions),
        AuthenticatorSelection_(_AuthenticatorSelection),
        attestationConveyancePreference_(_attestationConveyancePreference),
        Hints_(_Hints),
        TimeoutMS_(_TimeoutMS)
    {
    }

    MOZ_IMPLICIT WebAuthnMakeCredentialInfo(
            nsCString&& _RpId,
            nsTArray<uint8_t>&& _Challenge,
            uint32_t&& _TimeoutMS,
            nsTArray<WebAuthnScopedCredential>&& _ExcludeList,
            WebAuthnMakeCredentialRpInfo&& _Rp,
            WebAuthnMakeCredentialUserInfo&& _User,
            nsTArray<CoseAlg>&& _coseAlgs,
            nsTArray<WebAuthnExtension>&& _Extensions,
            WebAuthnAuthenticatorSelection&& _AuthenticatorSelection,
            nsString&& _attestationConveyancePreference,
            nsTArray<nsString>&& _Hints) :
        RpId_(std::move(_RpId)),
        Challenge_(std::move(_Challenge)),
        ExcludeList_(std::move(_ExcludeList)),
        Rp_(std::move(_Rp)),
        User_(std::move(_User)),
        coseAlgs_(std::move(_coseAlgs)),
        Extensions_(std::move(_Extensions)),
        AuthenticatorSelection_(std::move(_AuthenticatorSelection)),
        attestationConveyancePreference_(std::move(_attestationConveyancePreference)),
        Hints_(std::move(_Hints)),
        TimeoutMS_(std::move(_TimeoutMS))
    {
    }

    nsCString&
    RpId()
    {
        return RpId_;
    }
    const nsCString&
    RpId() const
    {
        return RpId_;
    }

    nsTArray<uint8_t>&
    Challenge()
    {
        return Challenge_;
    }
    const nsTArray<uint8_t>&
    Challenge() const
    {
        return Challenge_;
    }

    uint32_t&
    TimeoutMS()
    {
        return TimeoutMS_;
    }
    const uint32_t&
    TimeoutMS() const
    {
        return TimeoutMS_;
    }

    nsTArray<WebAuthnScopedCredential>&
    ExcludeList()
    {
        return ExcludeList_;
    }
    const nsTArray<WebAuthnScopedCredential>&
    ExcludeList() const
    {
        return ExcludeList_;
    }

    WebAuthnMakeCredentialRpInfo&
    Rp()
    {
        return Rp_;
    }
    const WebAuthnMakeCredentialRpInfo&
    Rp() const
    {
        return Rp_;
    }

    WebAuthnMakeCredentialUserInfo&
    User()
    {
        return User_;
    }
    const WebAuthnMakeCredentialUserInfo&
    User() const
    {
        return User_;
    }

    nsTArray<CoseAlg>&
    coseAlgs()
    {
        return coseAlgs_;
    }
    const nsTArray<CoseAlg>&
    coseAlgs() const
    {
        return coseAlgs_;
    }

    nsTArray<WebAuthnExtension>&
    Extensions()
    {
        return Extensions_;
    }
    const nsTArray<WebAuthnExtension>&
    Extensions() const
    {
        return Extensions_;
    }

    WebAuthnAuthenticatorSelection&
    AuthenticatorSelection()
    {
        return AuthenticatorSelection_;
    }
    const WebAuthnAuthenticatorSelection&
    AuthenticatorSelection() const
    {
        return AuthenticatorSelection_;
    }

    nsString&
    attestationConveyancePreference()
    {
        return attestationConveyancePreference_;
    }
    const nsString&
    attestationConveyancePreference() const
    {
        return attestationConveyancePreference_;
    }

    nsTArray<nsString>&
    Hints()
    {
        return Hints_;
    }
    const nsTArray<nsString>&
    Hints() const
    {
        return Hints_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> RpId_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnScopedCredential>> ExcludeList_;
    ::mozilla::ipc::IPDLStructMember<WebAuthnMakeCredentialRpInfo> Rp_;
    ::mozilla::ipc::IPDLStructMember<WebAuthnMakeCredentialUserInfo> User_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CoseAlg>> coseAlgs_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtension>> Extensions_;
    ::mozilla::ipc::IPDLStructMember<WebAuthnAuthenticatorSelection> AuthenticatorSelection_;
    ::mozilla::ipc::IPDLStructMember<nsString> attestationConveyancePreference_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> Hints_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> TimeoutMS_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialResult|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialResult final
{
private:
    typedef ::nsCString nsCString;
    typedef ::uint8_t uint8_t;
    typedef ::nsString nsString;
    typedef ::mozilla::dom::WebAuthnExtensionResult WebAuthnExtensionResult;

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

    MOZ_IMPLICIT WebAuthnMakeCredentialResult(
            const nsCString& _ClientDataJSON,
            const nsTArray<uint8_t>& _AttestationObject,
            const nsTArray<uint8_t>& _KeyHandle,
            const nsTArray<nsString>& _Transports,
            const nsTArray<WebAuthnExtensionResult>& _Extensions,
            const mozilla::Maybe<nsString>& _AuthenticatorAttachment) :
        ClientDataJSON_(_ClientDataJSON),
        AttestationObject_(_AttestationObject),
        KeyHandle_(_KeyHandle),
        Transports_(_Transports),
        Extensions_(_Extensions),
        AuthenticatorAttachment_(_AuthenticatorAttachment)
    {
    }

    MOZ_IMPLICIT WebAuthnMakeCredentialResult(
            nsCString&& _ClientDataJSON,
            nsTArray<uint8_t>&& _AttestationObject,
            nsTArray<uint8_t>&& _KeyHandle,
            nsTArray<nsString>&& _Transports,
            nsTArray<WebAuthnExtensionResult>&& _Extensions,
            mozilla::Maybe<nsString>&& _AuthenticatorAttachment) :
        ClientDataJSON_(std::move(_ClientDataJSON)),
        AttestationObject_(std::move(_AttestationObject)),
        KeyHandle_(std::move(_KeyHandle)),
        Transports_(std::move(_Transports)),
        Extensions_(std::move(_Extensions)),
        AuthenticatorAttachment_(std::move(_AuthenticatorAttachment))
    {
    }

    nsCString&
    ClientDataJSON()
    {
        return ClientDataJSON_;
    }
    const nsCString&
    ClientDataJSON() const
    {
        return ClientDataJSON_;
    }

    nsTArray<uint8_t>&
    AttestationObject()
    {
        return AttestationObject_;
    }
    const nsTArray<uint8_t>&
    AttestationObject() const
    {
        return AttestationObject_;
    }

    nsTArray<uint8_t>&
    KeyHandle()
    {
        return KeyHandle_;
    }
    const nsTArray<uint8_t>&
    KeyHandle() const
    {
        return KeyHandle_;
    }

    nsTArray<nsString>&
    Transports()
    {
        return Transports_;
    }
    const nsTArray<nsString>&
    Transports() const
    {
        return Transports_;
    }

    nsTArray<WebAuthnExtensionResult>&
    Extensions()
    {
        return Extensions_;
    }
    const nsTArray<WebAuthnExtensionResult>&
    Extensions() const
    {
        return Extensions_;
    }

    mozilla::Maybe<nsString>&
    AuthenticatorAttachment()
    {
        return AuthenticatorAttachment_;
    }
    const mozilla::Maybe<nsString>&
    AuthenticatorAttachment() const
    {
        return AuthenticatorAttachment_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> AttestationObject_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> KeyHandle_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> Transports_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionResult>> Extensions_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> AuthenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla

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


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

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::WebAuthnMakeCredentialResult WebAuthnMakeCredentialResult;
    typedef nsresult nsresult__tdef;
    typedef WebAuthnMakeCredentialResult WebAuthnMakeCredentialResult__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    WebAuthnMakeCredentialResult*
    ptr_WebAuthnMakeCredentialResult()
    {
        return (&(mVWebAuthnMakeCredentialResult));
    }
    const WebAuthnMakeCredentialResult*
    constptr_WebAuthnMakeCredentialResult() const
    {
        return (&(mVWebAuthnMakeCredentialResult));
    }

    void
    MaybeDestroy();

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

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

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const nsresult& aOther);

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(nsresult&& aOther);

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResult& aOther);

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResult&& aOther);

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResponse& aOther);

    MOZ_IMPLICIT WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResponse&& aOther);

    ~WebAuthnMakeCredentialResponse();

    Type
    type() const
    {
        return mType;
    }

    WebAuthnMakeCredentialResponse&
    operator=(const nsresult& aRhs);

    WebAuthnMakeCredentialResponse&
    operator=(nsresult&& aRhs);

    WebAuthnMakeCredentialResponse&
    operator=(const WebAuthnMakeCredentialResult& aRhs);

    WebAuthnMakeCredentialResponse&
    operator=(WebAuthnMakeCredentialResult&& aRhs);

    WebAuthnMakeCredentialResponse&
    operator=(const WebAuthnMakeCredentialResponse& aRhs);

    WebAuthnMakeCredentialResponse&
    operator=(WebAuthnMakeCredentialResponse&& aRhs);

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

    WebAuthnMakeCredentialResult&
    get_WebAuthnMakeCredentialResult()
    {
        AssertSanity(TWebAuthnMakeCredentialResult);
        return (*(ptr_WebAuthnMakeCredentialResult()));
    }
    const WebAuthnMakeCredentialResult&
    get_WebAuthnMakeCredentialResult() const
    {
        AssertSanity(TWebAuthnMakeCredentialResult);
        return (*(constptr_WebAuthnMakeCredentialResult()));
    }
    operator WebAuthnMakeCredentialResult&()
    {
        return get_WebAuthnMakeCredentialResult();
    }
    operator const WebAuthnMakeCredentialResult&() const
    {
        return get_WebAuthnMakeCredentialResult();
    }

private:
    union {
        nsresult mVnsresult;
        WebAuthnMakeCredentialResult mVWebAuthnMakeCredentialResult;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnGetAssertionInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionInfo final
{
private:
    typedef ::nsCString nsCString;
    typedef ::uint8_t uint8_t;
    typedef ::uint32_t uint32_t;
    typedef ::mozilla::dom::WebAuthnScopedCredential WebAuthnScopedCredential;
    typedef ::mozilla::dom::WebAuthnExtension WebAuthnExtension;
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnGetAssertionInfo(
            const nsCString& _RpId,
            const mozilla::Maybe<nsCString>& _AppId,
            const nsTArray<uint8_t>& _Challenge,
            const uint32_t& _TimeoutMS,
            const nsTArray<WebAuthnScopedCredential>& _AllowList,
            const nsTArray<WebAuthnExtension>& _Extensions,
            const nsString& _userVerificationRequirement,
            const bool& _ConditionallyMediated,
            const nsTArray<nsString>& _Hints) :
        RpId_(_RpId),
        AppId_(_AppId),
        Challenge_(_Challenge),
        AllowList_(_AllowList),
        Extensions_(_Extensions),
        userVerificationRequirement_(_userVerificationRequirement),
        ConditionallyMediated_(_ConditionallyMediated),
        Hints_(_Hints),
        TimeoutMS_(_TimeoutMS)
    {
    }

    MOZ_IMPLICIT WebAuthnGetAssertionInfo(
            nsCString&& _RpId,
            mozilla::Maybe<nsCString>&& _AppId,
            nsTArray<uint8_t>&& _Challenge,
            uint32_t&& _TimeoutMS,
            nsTArray<WebAuthnScopedCredential>&& _AllowList,
            nsTArray<WebAuthnExtension>&& _Extensions,
            nsString&& _userVerificationRequirement,
            bool&& _ConditionallyMediated,
            nsTArray<nsString>&& _Hints) :
        RpId_(std::move(_RpId)),
        AppId_(std::move(_AppId)),
        Challenge_(std::move(_Challenge)),
        AllowList_(std::move(_AllowList)),
        Extensions_(std::move(_Extensions)),
        userVerificationRequirement_(std::move(_userVerificationRequirement)),
        ConditionallyMediated_(std::move(_ConditionallyMediated)),
        Hints_(std::move(_Hints)),
        TimeoutMS_(std::move(_TimeoutMS))
    {
    }

    nsCString&
    RpId()
    {
        return RpId_;
    }
    const nsCString&
    RpId() const
    {
        return RpId_;
    }

    mozilla::Maybe<nsCString>&
    AppId()
    {
        return AppId_;
    }
    const mozilla::Maybe<nsCString>&
    AppId() const
    {
        return AppId_;
    }

    nsTArray<uint8_t>&
    Challenge()
    {
        return Challenge_;
    }
    const nsTArray<uint8_t>&
    Challenge() const
    {
        return Challenge_;
    }

    uint32_t&
    TimeoutMS()
    {
        return TimeoutMS_;
    }
    const uint32_t&
    TimeoutMS() const
    {
        return TimeoutMS_;
    }

    nsTArray<WebAuthnScopedCredential>&
    AllowList()
    {
        return AllowList_;
    }
    const nsTArray<WebAuthnScopedCredential>&
    AllowList() const
    {
        return AllowList_;
    }

    nsTArray<WebAuthnExtension>&
    Extensions()
    {
        return Extensions_;
    }
    const nsTArray<WebAuthnExtension>&
    Extensions() const
    {
        return Extensions_;
    }

    nsString&
    userVerificationRequirement()
    {
        return userVerificationRequirement_;
    }
    const nsString&
    userVerificationRequirement() const
    {
        return userVerificationRequirement_;
    }

    bool&
    ConditionallyMediated()
    {
        return ConditionallyMediated_;
    }
    const bool&
    ConditionallyMediated() const
    {
        return ConditionallyMediated_;
    }

    nsTArray<nsString>&
    Hints()
    {
        return Hints_;
    }
    const nsTArray<nsString>&
    Hints() const
    {
        return Hints_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> RpId_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> AppId_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnScopedCredential>> AllowList_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtension>> Extensions_;
    ::mozilla::ipc::IPDLStructMember<nsString> userVerificationRequirement_;
    ::mozilla::ipc::IPDLStructMember<bool> ConditionallyMediated_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> Hints_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> TimeoutMS_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnGetAssertionResult|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionResult final
{
private:
    typedef ::nsCString nsCString;
    typedef ::uint8_t uint8_t;
    typedef ::mozilla::dom::WebAuthnExtensionResult WebAuthnExtensionResult;
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT WebAuthnGetAssertionResult(
            const nsCString& _ClientDataJSON,
            const nsTArray<uint8_t>& _KeyHandle,
            const nsTArray<uint8_t>& _Signature,
            const nsTArray<uint8_t>& _AuthenticatorData,
            const nsTArray<WebAuthnExtensionResult>& _Extensions,
            const nsTArray<uint8_t>& _UserHandle,
            const mozilla::Maybe<nsString>& _AuthenticatorAttachment) :
        ClientDataJSON_(_ClientDataJSON),
        KeyHandle_(_KeyHandle),
        Signature_(_Signature),
        AuthenticatorData_(_AuthenticatorData),
        Extensions_(_Extensions),
        UserHandle_(_UserHandle),
        AuthenticatorAttachment_(_AuthenticatorAttachment)
    {
    }

    MOZ_IMPLICIT WebAuthnGetAssertionResult(
            nsCString&& _ClientDataJSON,
            nsTArray<uint8_t>&& _KeyHandle,
            nsTArray<uint8_t>&& _Signature,
            nsTArray<uint8_t>&& _AuthenticatorData,
            nsTArray<WebAuthnExtensionResult>&& _Extensions,
            nsTArray<uint8_t>&& _UserHandle,
            mozilla::Maybe<nsString>&& _AuthenticatorAttachment) :
        ClientDataJSON_(std::move(_ClientDataJSON)),
        KeyHandle_(std::move(_KeyHandle)),
        Signature_(std::move(_Signature)),
        AuthenticatorData_(std::move(_AuthenticatorData)),
        Extensions_(std::move(_Extensions)),
        UserHandle_(std::move(_UserHandle)),
        AuthenticatorAttachment_(std::move(_AuthenticatorAttachment))
    {
    }

    nsCString&
    ClientDataJSON()
    {
        return ClientDataJSON_;
    }
    const nsCString&
    ClientDataJSON() const
    {
        return ClientDataJSON_;
    }

    nsTArray<uint8_t>&
    KeyHandle()
    {
        return KeyHandle_;
    }
    const nsTArray<uint8_t>&
    KeyHandle() const
    {
        return KeyHandle_;
    }

    nsTArray<uint8_t>&
    Signature()
    {
        return Signature_;
    }
    const nsTArray<uint8_t>&
    Signature() const
    {
        return Signature_;
    }

    nsTArray<uint8_t>&
    AuthenticatorData()
    {
        return AuthenticatorData_;
    }
    const nsTArray<uint8_t>&
    AuthenticatorData() const
    {
        return AuthenticatorData_;
    }

    nsTArray<WebAuthnExtensionResult>&
    Extensions()
    {
        return Extensions_;
    }
    const nsTArray<WebAuthnExtensionResult>&
    Extensions() const
    {
        return Extensions_;
    }

    nsTArray<uint8_t>&
    UserHandle()
    {
        return UserHandle_;
    }
    const nsTArray<uint8_t>&
    UserHandle() const
    {
        return UserHandle_;
    }

    mozilla::Maybe<nsString>&
    AuthenticatorAttachment()
    {
        return AuthenticatorAttachment_;
    }
    const mozilla::Maybe<nsString>&
    AuthenticatorAttachment() const
    {
        return AuthenticatorAttachment_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> KeyHandle_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Signature_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> AuthenticatorData_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionResult>> Extensions_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> UserHandle_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> AuthenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla

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


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

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::WebAuthnGetAssertionResult WebAuthnGetAssertionResult;
    typedef nsresult nsresult__tdef;
    typedef WebAuthnGetAssertionResult WebAuthnGetAssertionResult__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    WebAuthnGetAssertionResult*
    ptr_WebAuthnGetAssertionResult()
    {
        return (&(mVWebAuthnGetAssertionResult));
    }
    const WebAuthnGetAssertionResult*
    constptr_WebAuthnGetAssertionResult() const
    {
        return (&(mVWebAuthnGetAssertionResult));
    }

    void
    MaybeDestroy();

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

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

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(const nsresult& aOther);

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(nsresult&& aOther);

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResult& aOther);

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(WebAuthnGetAssertionResult&& aOther);

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResponse& aOther);

    MOZ_IMPLICIT WebAuthnGetAssertionResponse(WebAuthnGetAssertionResponse&& aOther);

    ~WebAuthnGetAssertionResponse();

    Type
    type() const
    {
        return mType;
    }

    WebAuthnGetAssertionResponse&
    operator=(const nsresult& aRhs);

    WebAuthnGetAssertionResponse&
    operator=(nsresult&& aRhs);

    WebAuthnGetAssertionResponse&
    operator=(const WebAuthnGetAssertionResult& aRhs);

    WebAuthnGetAssertionResponse&
    operator=(WebAuthnGetAssertionResult&& aRhs);

    WebAuthnGetAssertionResponse&
    operator=(const WebAuthnGetAssertionResponse& aRhs);

    WebAuthnGetAssertionResponse&
    operator=(WebAuthnGetAssertionResponse&& aRhs);

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

    WebAuthnGetAssertionResult&
    get_WebAuthnGetAssertionResult()
    {
        AssertSanity(TWebAuthnGetAssertionResult);
        return (*(ptr_WebAuthnGetAssertionResult()));
    }
    const WebAuthnGetAssertionResult&
    get_WebAuthnGetAssertionResult() const
    {
        AssertSanity(TWebAuthnGetAssertionResult);
        return (*(constptr_WebAuthnGetAssertionResult()));
    }
    operator WebAuthnGetAssertionResult&()
    {
        return get_WebAuthnGetAssertionResult();
    }
    operator const WebAuthnGetAssertionResult&() const
    {
        return get_WebAuthnGetAssertionResult();
    }

private:
    union {
        nsresult mVnsresult;
        WebAuthnGetAssertionResult mVWebAuthnGetAssertionResult;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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

namespace mozilla {
namespace dom {
class PWebAuthnTransactionParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebAuthnTransactionChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PWebAuthnTransactionChild and PWebAuthnTransactionParent
//
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);

nsresult
CreateEndpoints(
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild);

enum MessageType {
    PWebAuthnTransactionStart = PWebAuthnTransactionMsgStart << 16,
    Msg_RequestRegister__ID,
    Reply_RequestRegister__ID,
    Msg_RequestSign__ID,
    Reply_RequestSign__ID,
    Msg_RequestIsUVPAA__ID,
    Reply_RequestIsUVPAA__ID,
    Msg_RequestCancel__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PWebAuthnTransactionEnd
};

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

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

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

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

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



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

#endif // ifndef PWebAuthnTransaction_h
