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

#ifndef IPCServiceWorkerRegistrationDescriptor_h
#define IPCServiceWorkerRegistrationDescriptor_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/ErrorResult.h"
#include "mozilla/dom/ServiceWorkerRegistrationBinding.h"
#include "mozilla/dom/WorkerBinding.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCServiceWorkerRegistrationDescriptor|
//
namespace mozilla {
namespace dom {
class IPCServiceWorkerRegistrationDescriptor final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::nsCString nsCString;
    typedef ::mozilla::dom::WorkerType WorkerType;
    typedef ::mozilla::dom::ServiceWorkerUpdateViaCache ServiceWorkerUpdateViaCache;
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;

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

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptor(
            const uint64_t& _id,
            const uint64_t& _version,
            const PrincipalInfo& _principalInfo,
            const nsCString& _scope,
            const WorkerType& _type,
            const ServiceWorkerUpdateViaCache& _updateViaCache,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _installing,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _waiting,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _active) :
        principalInfo_(_principalInfo),
        scope_(_scope),
        type_(_type),
        updateViaCache_(_updateViaCache),
        installing_(_installing),
        waiting_(_waiting),
        active_(_active),
        id_(_id),
        version_(_version)
    {
    }

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptor(
            uint64_t&& _id,
            uint64_t&& _version,
            PrincipalInfo&& _principalInfo,
            nsCString&& _scope,
            WorkerType&& _type,
            ServiceWorkerUpdateViaCache&& _updateViaCache,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _installing,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _waiting,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _active) :
        principalInfo_(std::move(_principalInfo)),
        scope_(std::move(_scope)),
        type_(std::move(_type)),
        updateViaCache_(std::move(_updateViaCache)),
        installing_(std::move(_installing)),
        waiting_(std::move(_waiting)),
        active_(std::move(_active)),
        id_(std::move(_id)),
        version_(std::move(_version))
    {
    }

    bool
    operator==(const IPCServiceWorkerRegistrationDescriptor& _o) const;

    bool
    operator!=(const IPCServiceWorkerRegistrationDescriptor& _o) const;

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

    uint64_t&
    version()
    {
        return version_;
    }
    const uint64_t&
    version() const
    {
        return version_;
    }

    PrincipalInfo&
    principalInfo()
    {
        return principalInfo_;
    }
    const PrincipalInfo&
    principalInfo() const
    {
        return principalInfo_;
    }

    nsCString&
    scope()
    {
        return scope_;
    }
    const nsCString&
    scope() const
    {
        return scope_;
    }

    WorkerType&
    type()
    {
        return type_;
    }
    const WorkerType&
    type() const
    {
        return type_;
    }

    ServiceWorkerUpdateViaCache&
    updateViaCache()
    {
        return updateViaCache_;
    }
    const ServiceWorkerUpdateViaCache&
    updateViaCache() const
    {
        return updateViaCache_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    installing()
    {
        return installing_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    installing() const
    {
        return installing_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    waiting()
    {
        return waiting_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    waiting() const
    {
        return waiting_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    active()
    {
        return active_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    active() const
    {
        return active_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<nsCString> scope_;
    ::mozilla::ipc::IPDLStructMember<WorkerType> type_;
    ::mozilla::ipc::IPDLStructMember<ServiceWorkerUpdateViaCache> updateViaCache_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> installing_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> waiting_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> active_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> id_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> version_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCServiceWorkerRegistrationDescriptor>
{
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptor 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 IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult|
//
namespace mozilla {
namespace dom {
class IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult final
{
public:
    enum Type {
        T__None,
        TIPCServiceWorkerRegistrationDescriptor = 1,
        TCopyableErrorResult,
        T__Last = TCopyableErrorResult
    };

private:
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptor IPCServiceWorkerRegistrationDescriptor;
    typedef ::mozilla::CopyableErrorResult CopyableErrorResult;
    typedef IPCServiceWorkerRegistrationDescriptor IPCServiceWorkerRegistrationDescriptor__tdef;
    typedef CopyableErrorResult CopyableErrorResult__tdef;

    IPCServiceWorkerRegistrationDescriptor*
    ptr_IPCServiceWorkerRegistrationDescriptor()
    {
        return (&(mVIPCServiceWorkerRegistrationDescriptor));
    }
    const IPCServiceWorkerRegistrationDescriptor*
    constptr_IPCServiceWorkerRegistrationDescriptor() const
    {
        return (&(mVIPCServiceWorkerRegistrationDescriptor));
    }
    CopyableErrorResult*
    ptr_CopyableErrorResult()
    {
        return (&(mVCopyableErrorResult));
    }
    const CopyableErrorResult*
    constptr_CopyableErrorResult() const
    {
        return (&(mVCopyableErrorResult));
    }

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

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(const IPCServiceWorkerRegistrationDescriptor& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(IPCServiceWorkerRegistrationDescriptor&& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(const CopyableErrorResult& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(CopyableErrorResult&& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(const IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult(IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&& aOther);

    ~IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult();

    Type
    type() const
    {
        return mType;
    }

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(const IPCServiceWorkerRegistrationDescriptor& aRhs);

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(IPCServiceWorkerRegistrationDescriptor&& aRhs);

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(const CopyableErrorResult& aRhs);

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(CopyableErrorResult&& aRhs);

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(const IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult& aRhs);

    IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&
    operator=(IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&& aRhs);

    IPCServiceWorkerRegistrationDescriptor&
    get_IPCServiceWorkerRegistrationDescriptor()
    {
        AssertSanity(TIPCServiceWorkerRegistrationDescriptor);
        return (*(ptr_IPCServiceWorkerRegistrationDescriptor()));
    }
    const IPCServiceWorkerRegistrationDescriptor&
    get_IPCServiceWorkerRegistrationDescriptor() const
    {
        AssertSanity(TIPCServiceWorkerRegistrationDescriptor);
        return (*(constptr_IPCServiceWorkerRegistrationDescriptor()));
    }
    operator IPCServiceWorkerRegistrationDescriptor&()
    {
        return get_IPCServiceWorkerRegistrationDescriptor();
    }
    operator const IPCServiceWorkerRegistrationDescriptor&() const
    {
        return get_IPCServiceWorkerRegistrationDescriptor();
    }

    CopyableErrorResult&
    get_CopyableErrorResult()
    {
        AssertSanity(TCopyableErrorResult);
        return (*(ptr_CopyableErrorResult()));
    }
    const CopyableErrorResult&
    get_CopyableErrorResult() const
    {
        AssertSanity(TCopyableErrorResult);
        return (*(constptr_CopyableErrorResult()));
    }
    operator CopyableErrorResult&()
    {
        return get_CopyableErrorResult();
    }
    operator const CopyableErrorResult&() const
    {
        return get_CopyableErrorResult();
    }

private:
    union {
        IPCServiceWorkerRegistrationDescriptor mVIPCServiceWorkerRegistrationDescriptor;
        CopyableErrorResult mVCopyableErrorResult;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult>
{
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult 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 IPCServiceWorkerRegistrationDescriptorList|
//
namespace mozilla {
namespace dom {
class IPCServiceWorkerRegistrationDescriptorList final
{
private:
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptor IPCServiceWorkerRegistrationDescriptor;

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

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorList(const nsTArray<IPCServiceWorkerRegistrationDescriptor>& _values) :
        values_(_values)
    {
    }

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorList(nsTArray<IPCServiceWorkerRegistrationDescriptor>&& _values) :
        values_(std::move(_values))
    {
    }

    nsTArray<IPCServiceWorkerRegistrationDescriptor>&
    values()
    {
        return values_;
    }
    const nsTArray<IPCServiceWorkerRegistrationDescriptor>&
    values() const
    {
        return values_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCServiceWorkerRegistrationDescriptor>> values_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCServiceWorkerRegistrationDescriptorList>
{
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorList 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 IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult|
//
namespace mozilla {
namespace dom {
class IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult final
{
public:
    enum Type {
        T__None,
        TIPCServiceWorkerRegistrationDescriptorList = 1,
        TCopyableErrorResult,
        T__Last = TCopyableErrorResult
    };

private:
    typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptorList IPCServiceWorkerRegistrationDescriptorList;
    typedef ::mozilla::CopyableErrorResult CopyableErrorResult;
    typedef IPCServiceWorkerRegistrationDescriptorList IPCServiceWorkerRegistrationDescriptorList__tdef;
    typedef CopyableErrorResult CopyableErrorResult__tdef;

    IPCServiceWorkerRegistrationDescriptorList*
    ptr_IPCServiceWorkerRegistrationDescriptorList()
    {
        return (&(mVIPCServiceWorkerRegistrationDescriptorList));
    }
    const IPCServiceWorkerRegistrationDescriptorList*
    constptr_IPCServiceWorkerRegistrationDescriptorList() const
    {
        return (&(mVIPCServiceWorkerRegistrationDescriptorList));
    }
    CopyableErrorResult*
    ptr_CopyableErrorResult()
    {
        return (&(mVCopyableErrorResult));
    }
    const CopyableErrorResult*
    constptr_CopyableErrorResult() const
    {
        return (&(mVCopyableErrorResult));
    }

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

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(const IPCServiceWorkerRegistrationDescriptorList& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(IPCServiceWorkerRegistrationDescriptorList&& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(const CopyableErrorResult& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(CopyableErrorResult&& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(const IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult& aOther);

    MOZ_IMPLICIT IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult(IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&& aOther);

    ~IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult();

    Type
    type() const
    {
        return mType;
    }

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(const IPCServiceWorkerRegistrationDescriptorList& aRhs);

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(IPCServiceWorkerRegistrationDescriptorList&& aRhs);

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(const CopyableErrorResult& aRhs);

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(CopyableErrorResult&& aRhs);

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(const IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult& aRhs);

    IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&
    operator=(IPCServiceWorkerRegistrationDescriptorListOrCopyableErrorResult&& aRhs);

    IPCServiceWorkerRegistrationDescriptorList&
    get_IPCServiceWorkerRegistrationDescriptorList()
    {
        AssertSanity(TIPCServiceWorkerRegistrationDescriptorList);
        return (*(ptr_IPCServiceWorkerRegistrationDescriptorList()));
    }
    const IPCServiceWorkerRegistrationDescriptorList&
    get_IPCServiceWorkerRegistrationDescriptorList() const
    {
        AssertSanity(TIPCServiceWorkerRegistrationDescriptorList);
        return (*(constptr_IPCServiceWorkerRegistrationDescriptorList()));
    }
    operator IPCServiceWorkerRegistrationDescriptorList&()
    {
        return get_IPCServiceWorkerRegistrationDescriptorList();
    }
    operator const IPCServiceWorkerRegistrationDescriptorList&() const
    {
        return get_IPCServiceWorkerRegistrationDescriptorList();
    }

    CopyableErrorResult&
    get_CopyableErrorResult()
    {
        AssertSanity(TCopyableErrorResult);
        return (*(ptr_CopyableErrorResult()));
    }
    const CopyableErrorResult&
    get_CopyableErrorResult() const
    {
        AssertSanity(TCopyableErrorResult);
        return (*(constptr_CopyableErrorResult()));
    }
    operator CopyableErrorResult&()
    {
        return get_CopyableErrorResult();
    }
    operator const CopyableErrorResult&() const
    {
        return get_CopyableErrorResult();
    }

private:
    union {
        IPCServiceWorkerRegistrationDescriptorList mVIPCServiceWorkerRegistrationDescriptorList;
        CopyableErrorResult mVCopyableErrorResult;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef IPCServiceWorkerRegistrationDescriptor_h
