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

#ifndef PWebIdentity_h
#define PWebIdentity_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/ipc/IPDLStructMember.h"


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

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

    MOZ_IMPLICIT IPCIdentityCredential(
            const nsString& _id,
            const mozilla::Maybe<nsCString>& _token,
            const bool& _isAutoSelected,
            const nsCString& _configURL) :
        id_(_id),
        token_(_token),
        isAutoSelected_(_isAutoSelected),
        configURL_(_configURL)
    {
    }

    MOZ_IMPLICIT IPCIdentityCredential(
            nsString&& _id,
            mozilla::Maybe<nsCString>&& _token,
            bool&& _isAutoSelected,
            nsCString&& _configURL) :
        id_(std::move(_id)),
        token_(std::move(_token)),
        isAutoSelected_(std::move(_isAutoSelected)),
        configURL_(std::move(_configURL))
    {
    }

    nsString&
    id()
    {
        return id_;
    }
    const nsString&
    id() const
    {
        return id_;
    }

    mozilla::Maybe<nsCString>&
    token()
    {
        return token_;
    }
    const mozilla::Maybe<nsCString>&
    token() const
    {
        return token_;
    }

    bool&
    isAutoSelected()
    {
        return isAutoSelected_;
    }
    const bool&
    isAutoSelected() const
    {
        return isAutoSelected_;
    }

    nsCString&
    configURL()
    {
        return configURL_;
    }
    const nsCString&
    configURL() const
    {
        return configURL_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> id_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> token_;
    ::mozilla::ipc::IPDLStructMember<bool> isAutoSelected_;
    ::mozilla::ipc::IPDLStructMember<nsCString> configURL_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCIdentityCredential>
{
    typedef ::mozilla::dom::IPCIdentityCredential 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 WebIdentityGetCredentialResponse|
//
namespace mozilla {
namespace dom {
class WebIdentityGetCredentialResponse final
{
public:
    enum Type {
        T__None,
        Tnsresult = 1,
        TIPCIdentityCredential,
        T__Last = TIPCIdentityCredential
    };

private:
    typedef ::nsresult nsresult;
    typedef ::mozilla::dom::IPCIdentityCredential IPCIdentityCredential;
    typedef nsresult nsresult__tdef;
    typedef IPCIdentityCredential IPCIdentityCredential__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    IPCIdentityCredential*
    ptr_IPCIdentityCredential()
    {
        return (&(mVIPCIdentityCredential));
    }
    const IPCIdentityCredential*
    constptr_IPCIdentityCredential() const
    {
        return (&(mVIPCIdentityCredential));
    }

    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 WebIdentityGetCredentialResponse() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(const nsresult& aOther);

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(nsresult&& aOther);

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(const IPCIdentityCredential& aOther);

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(IPCIdentityCredential&& aOther);

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(const WebIdentityGetCredentialResponse& aOther);

    MOZ_IMPLICIT WebIdentityGetCredentialResponse(WebIdentityGetCredentialResponse&& aOther);

    ~WebIdentityGetCredentialResponse();

    Type
    type() const
    {
        return mType;
    }

    WebIdentityGetCredentialResponse&
    operator=(const nsresult& aRhs);

    WebIdentityGetCredentialResponse&
    operator=(nsresult&& aRhs);

    WebIdentityGetCredentialResponse&
    operator=(const IPCIdentityCredential& aRhs);

    WebIdentityGetCredentialResponse&
    operator=(IPCIdentityCredential&& aRhs);

    WebIdentityGetCredentialResponse&
    operator=(const WebIdentityGetCredentialResponse& aRhs);

    WebIdentityGetCredentialResponse&
    operator=(WebIdentityGetCredentialResponse&& 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();
    }

    IPCIdentityCredential&
    get_IPCIdentityCredential()
    {
        AssertSanity(TIPCIdentityCredential);
        return (*(ptr_IPCIdentityCredential()));
    }
    const IPCIdentityCredential&
    get_IPCIdentityCredential() const
    {
        AssertSanity(TIPCIdentityCredential);
        return (*(constptr_IPCIdentityCredential()));
    }
    operator IPCIdentityCredential&()
    {
        return get_IPCIdentityCredential();
    }
    operator const IPCIdentityCredential&() const
    {
        return get_IPCIdentityCredential();
    }

private:
    union {
        nsresult mVnsresult;
        IPCIdentityCredential mVIPCIdentityCredential;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebIdentityGetCredentialResponse>
{
    typedef ::mozilla::dom::WebIdentityGetCredentialResponse 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 OpenContinuationWindowResponse|
//
namespace mozilla {
namespace dom {
class OpenContinuationWindowResponse final
{
public:
    enum Type {
        T__None,
        Tnsresult = 1,
        Tuint64_t,
        T__Last = Tuint64_t
    };

private:
    typedef ::nsresult nsresult;
    typedef ::uint64_t uint64_t;
    typedef nsresult nsresult__tdef;
    typedef uint64_t uint64_t__tdef;

    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }
    uint64_t*
    ptr_uint64_t()
    {
        return (&(mVuint64_t));
    }
    const uint64_t*
    constptr_uint64_t() const
    {
        return (&(mVuint64_t));
    }

    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 OpenContinuationWindowResponse() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT OpenContinuationWindowResponse(const nsresult& aOther);

    MOZ_IMPLICIT OpenContinuationWindowResponse(nsresult&& aOther);

    MOZ_IMPLICIT OpenContinuationWindowResponse(const uint64_t& aOther);

    MOZ_IMPLICIT OpenContinuationWindowResponse(uint64_t&& aOther);

    MOZ_IMPLICIT OpenContinuationWindowResponse(const OpenContinuationWindowResponse& aOther);

    MOZ_IMPLICIT OpenContinuationWindowResponse(OpenContinuationWindowResponse&& aOther);

    ~OpenContinuationWindowResponse();

    Type
    type() const
    {
        return mType;
    }

    OpenContinuationWindowResponse&
    operator=(const nsresult& aRhs);

    OpenContinuationWindowResponse&
    operator=(nsresult&& aRhs);

    OpenContinuationWindowResponse&
    operator=(const uint64_t& aRhs);

    OpenContinuationWindowResponse&
    operator=(uint64_t&& aRhs);

    OpenContinuationWindowResponse&
    operator=(const OpenContinuationWindowResponse& aRhs);

    OpenContinuationWindowResponse&
    operator=(OpenContinuationWindowResponse&& 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();
    }

    uint64_t&
    get_uint64_t()
    {
        AssertSanity(Tuint64_t);
        return (*(ptr_uint64_t()));
    }
    const uint64_t&
    get_uint64_t() const
    {
        AssertSanity(Tuint64_t);
        return (*(constptr_uint64_t()));
    }
    operator uint64_t&()
    {
        return get_uint64_t();
    }
    operator const uint64_t&() const
    {
        return get_uint64_t();
    }

private:
    union {
        nsresult mVnsresult;
        uint64_t mVuint64_t;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::OpenContinuationWindowResponse>
{
    typedef ::mozilla::dom::OpenContinuationWindowResponse 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 PWebIdentityParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebIdentityChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PWebIdentityChild and PWebIdentityParent
//
namespace mozilla {
namespace dom {
namespace PWebIdentity {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityChild>* aChild);

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

enum MessageType {
    PWebIdentityStart = PWebIdentityMsgStart << 16,
    Msg_RequestCancel__ID,
    Msg_GetIdentityCredential__ID,
    Reply_GetIdentityCredential__ID,
    Msg_DisconnectIdentityCredential__ID,
    Reply_DisconnectIdentityCredential__ID,
    Msg_PreventSilentAccess__ID,
    Reply_PreventSilentAccess__ID,
    Msg_SetLoginStatus__ID,
    Reply_SetLoginStatus__ID,
    Msg_ResolveContinuationWindow__ID,
    Reply_ResolveContinuationWindow__ID,
    Msg_IsActiveContinuationWindow__ID,
    Reply_IsActiveContinuationWindow__ID,
    Msg_OpenContinuationWindow__ID,
    Reply_OpenContinuationWindow__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PWebIdentityEnd
};

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

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

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

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

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

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

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

mozilla::UniquePtr<IPC::Message>
Msg_OpenContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_OpenContinuationWindow(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 PWebIdentity
} // namespace dom
} // namespace mozilla

#endif // ifndef PWebIdentity_h
