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

#ifndef PDocAccessible_h
#define PDocAccessible_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/a11y/IPCTypes.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/a11y/DocAccessibleTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct AccessibleData|
//
namespace mozilla {
namespace a11y {
class AccessibleData final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::a11y::role role;
    typedef ::uint32_t uint32_t;
    typedef ::mozilla::a11y::AccType AccType;
    typedef ::mozilla::a11y::AccGenericType AccGenericType;
    typedef ::uint8_t uint8_t;
    typedef ::mozilla::a11y::AccAttributes AccAttributes;

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

    MOZ_IMPLICIT AccessibleData(
            const uint64_t& _ID,
            const role& _Role,
            const uint64_t& _ParentID,
            const uint32_t& _IndexInParent,
            const AccType& _Type,
            const AccGenericType& _GenericTypes,
            const uint8_t& _RoleMapEntryIndex,
            AccAttributes* _CacheFields) :
        Role_(_Role),
        Type_(_Type),
        GenericTypes_(_GenericTypes),
        CacheFields_(_CacheFields),
        ID_(_ID),
        ParentID_(_ParentID),
        IndexInParent_(_IndexInParent),
        RoleMapEntryIndex_(_RoleMapEntryIndex)
    {
    }

    MOZ_IMPLICIT AccessibleData(
            uint64_t&& _ID,
            role&& _Role,
            uint64_t&& _ParentID,
            uint32_t&& _IndexInParent,
            AccType&& _Type,
            AccGenericType&& _GenericTypes,
            uint8_t&& _RoleMapEntryIndex,
            RefPtr<AccAttributes>&& _CacheFields) :
        Role_(std::move(_Role)),
        Type_(std::move(_Type)),
        GenericTypes_(std::move(_GenericTypes)),
        CacheFields_(std::move(_CacheFields)),
        ID_(std::move(_ID)),
        ParentID_(std::move(_ParentID)),
        IndexInParent_(std::move(_IndexInParent)),
        RoleMapEntryIndex_(std::move(_RoleMapEntryIndex))
    {
    }

    uint64_t&
    ID()
    {
        return ID_;
    }
    const uint64_t&
    ID() const
    {
        return ID_;
    }

    role&
    Role()
    {
        return Role_;
    }
    const role&
    Role() const
    {
        return Role_;
    }

    uint64_t&
    ParentID()
    {
        return ParentID_;
    }
    const uint64_t&
    ParentID() const
    {
        return ParentID_;
    }

    uint32_t&
    IndexInParent()
    {
        return IndexInParent_;
    }
    const uint32_t&
    IndexInParent() const
    {
        return IndexInParent_;
    }

    AccType&
    Type()
    {
        return Type_;
    }
    const AccType&
    Type() const
    {
        return Type_;
    }

    AccGenericType&
    GenericTypes()
    {
        return GenericTypes_;
    }
    const AccGenericType&
    GenericTypes() const
    {
        return GenericTypes_;
    }

    uint8_t&
    RoleMapEntryIndex()
    {
        return RoleMapEntryIndex_;
    }
    const uint8_t&
    RoleMapEntryIndex() const
    {
        return RoleMapEntryIndex_;
    }

    RefPtr<AccAttributes>&
    CacheFields()
    {
        return CacheFields_;
    }
    AccAttributes*
    CacheFields() const
    {
        return CacheFields_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<role> Role_;
    ::mozilla::ipc::IPDLStructMember<AccType> Type_;
    ::mozilla::ipc::IPDLStructMember<AccGenericType> GenericTypes_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<AccAttributes>> CacheFields_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> ParentID_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> IndexInParent_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> RoleMapEntryIndex_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::AccessibleData>
{
    typedef ::mozilla::a11y::AccessibleData 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 CacheEventData|
//
namespace mozilla {
namespace a11y {
class CacheEventData final
{
private:
    typedef ::mozilla::a11y::CacheUpdateType CacheUpdateType;
    typedef ::mozilla::a11y::CacheData CacheData;

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

    MOZ_IMPLICIT CacheEventData(
            const CacheUpdateType& _UpdateType,
            const nsTArray<CacheData>& _aData) :
        UpdateType_(_UpdateType),
        aData_(_aData)
    {
    }

    MOZ_IMPLICIT CacheEventData(
            CacheUpdateType&& _UpdateType,
            nsTArray<CacheData>&& _aData) :
        UpdateType_(std::move(_UpdateType)),
        aData_(std::move(_aData))
    {
    }

    CacheUpdateType&
    UpdateType()
    {
        return UpdateType_;
    }
    const CacheUpdateType&
    UpdateType() const
    {
        return UpdateType_;
    }

    nsTArray<CacheData>&
    aData()
    {
        return aData_;
    }
    const nsTArray<CacheData>&
    aData() const
    {
        return aData_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CacheUpdateType> UpdateType_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CacheData>> aData_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::CacheEventData>
{
    typedef ::mozilla::a11y::CacheEventData 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 ShowEventData|
//
namespace mozilla {
namespace a11y {
class ShowEventData final
{
private:
    typedef ::mozilla::a11y::AccessibleData AccessibleData;

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

    MOZ_IMPLICIT ShowEventData(
            const nsTArray<AccessibleData>& _NewTree,
            const bool& _EventSuppressed,
            const bool& _Complete,
            const bool& _FromUser) :
        NewTree_(_NewTree),
        EventSuppressed_(_EventSuppressed),
        Complete_(_Complete),
        FromUser_(_FromUser)
    {
    }

    MOZ_IMPLICIT ShowEventData(
            nsTArray<AccessibleData>&& _NewTree,
            bool&& _EventSuppressed,
            bool&& _Complete,
            bool&& _FromUser) :
        NewTree_(std::move(_NewTree)),
        EventSuppressed_(std::move(_EventSuppressed)),
        Complete_(std::move(_Complete)),
        FromUser_(std::move(_FromUser))
    {
    }

    nsTArray<AccessibleData>&
    NewTree()
    {
        return NewTree_;
    }
    const nsTArray<AccessibleData>&
    NewTree() const
    {
        return NewTree_;
    }

    bool&
    EventSuppressed()
    {
        return EventSuppressed_;
    }
    const bool&
    EventSuppressed() const
    {
        return EventSuppressed_;
    }

    bool&
    Complete()
    {
        return Complete_;
    }
    const bool&
    Complete() const
    {
        return Complete_;
    }

    bool&
    FromUser()
    {
        return FromUser_;
    }
    const bool&
    FromUser() const
    {
        return FromUser_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<AccessibleData>> NewTree_;
    ::mozilla::ipc::IPDLStructMember<bool> EventSuppressed_;
    ::mozilla::ipc::IPDLStructMember<bool> Complete_;
    ::mozilla::ipc::IPDLStructMember<bool> FromUser_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::ShowEventData>
{
    typedef ::mozilla::a11y::ShowEventData 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 HideEventData|
//
namespace mozilla {
namespace a11y {
class HideEventData final
{
private:
    typedef ::uint64_t uint64_t;

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

    MOZ_IMPLICIT HideEventData(
            const uint64_t& _ID,
            const bool& _IsFromUserInput) :
        IsFromUserInput_(_IsFromUserInput),
        ID_(_ID)
    {
    }

    MOZ_IMPLICIT HideEventData(
            uint64_t&& _ID,
            bool&& _IsFromUserInput) :
        IsFromUserInput_(std::move(_IsFromUserInput)),
        ID_(std::move(_ID))
    {
    }

    uint64_t&
    ID()
    {
        return ID_;
    }
    const uint64_t&
    ID() const
    {
        return ID_;
    }

    bool&
    IsFromUserInput()
    {
        return IsFromUserInput_;
    }
    const bool&
    IsFromUserInput() const
    {
        return IsFromUserInput_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> IsFromUserInput_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::HideEventData>
{
    typedef ::mozilla::a11y::HideEventData 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 ReorderEventData|
//
namespace mozilla {
namespace a11y {
class ReorderEventData final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::uint32_t uint32_t;

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

    MOZ_IMPLICIT ReorderEventData(
            const uint64_t& _ID,
            const uint32_t& _Type) :
        ID_(_ID),
        Type_(_Type)
    {
    }

    MOZ_IMPLICIT ReorderEventData(
            uint64_t&& _ID,
            uint32_t&& _Type) :
        ID_(std::move(_ID)),
        Type_(std::move(_Type))
    {
    }

    uint64_t&
    ID()
    {
        return ID_;
    }
    const uint64_t&
    ID() const
    {
        return ID_;
    }

    uint32_t&
    Type()
    {
        return Type_;
    }
    const uint32_t&
    Type() const
    {
        return Type_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> Type_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::ReorderEventData>
{
    typedef ::mozilla::a11y::ReorderEventData 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 TextChangeEventData|
//
namespace mozilla {
namespace a11y {
class TextChangeEventData final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::nsString nsString;
    typedef ::int32_t int32_t;
    typedef ::uint32_t uint32_t;

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

    MOZ_IMPLICIT TextChangeEventData(
            const uint64_t& _ID,
            const nsString& _Str,
            const int32_t& _Start,
            const uint32_t& _Len,
            const bool& _IsInsert,
            const bool& _FromUser) :
        Str_(_Str),
        IsInsert_(_IsInsert),
        FromUser_(_FromUser),
        ID_(_ID),
        Start_(_Start),
        Len_(_Len)
    {
    }

    MOZ_IMPLICIT TextChangeEventData(
            uint64_t&& _ID,
            nsString&& _Str,
            int32_t&& _Start,
            uint32_t&& _Len,
            bool&& _IsInsert,
            bool&& _FromUser) :
        Str_(std::move(_Str)),
        IsInsert_(std::move(_IsInsert)),
        FromUser_(std::move(_FromUser)),
        ID_(std::move(_ID)),
        Start_(std::move(_Start)),
        Len_(std::move(_Len))
    {
    }

    uint64_t&
    ID()
    {
        return ID_;
    }
    const uint64_t&
    ID() const
    {
        return ID_;
    }

    nsString&
    Str()
    {
        return Str_;
    }
    const nsString&
    Str() const
    {
        return Str_;
    }

    int32_t&
    Start()
    {
        return Start_;
    }
    const int32_t&
    Start() const
    {
        return Start_;
    }

    uint32_t&
    Len()
    {
        return Len_;
    }
    const uint32_t&
    Len() const
    {
        return Len_;
    }

    bool&
    IsInsert()
    {
        return IsInsert_;
    }
    const bool&
    IsInsert() const
    {
        return IsInsert_;
    }

    bool&
    FromUser()
    {
        return FromUser_;
    }
    const bool&
    FromUser() const
    {
        return FromUser_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsString> Str_;
    ::mozilla::ipc::IPDLStructMember<bool> IsInsert_;
    ::mozilla::ipc::IPDLStructMember<bool> FromUser_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> ID_;
    ::mozilla::ipc::IPDLStructMember<int32_t> Start_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> Len_;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::TextChangeEventData>
{
    typedef ::mozilla::a11y::TextChangeEventData 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 MutationEventData|
//
namespace mozilla {
namespace a11y {
class MutationEventData final
{
public:
    enum Type {
        T__None,
        TCacheEventData = 1,
        TShowEventData,
        THideEventData,
        TReorderEventData,
        TTextChangeEventData,
        T__Last = TTextChangeEventData
    };

private:
    typedef ::mozilla::a11y::CacheEventData CacheEventData;
    typedef ::mozilla::a11y::ShowEventData ShowEventData;
    typedef ::mozilla::a11y::HideEventData HideEventData;
    typedef ::mozilla::a11y::ReorderEventData ReorderEventData;
    typedef ::mozilla::a11y::TextChangeEventData TextChangeEventData;
    typedef CacheEventData CacheEventData__tdef;
    typedef ShowEventData ShowEventData__tdef;
    typedef HideEventData HideEventData__tdef;
    typedef ReorderEventData ReorderEventData__tdef;
    typedef TextChangeEventData TextChangeEventData__tdef;

    CacheEventData*
    ptr_CacheEventData()
    {
        return (&(mVCacheEventData));
    }
    const CacheEventData*
    constptr_CacheEventData() const
    {
        return (&(mVCacheEventData));
    }
    ShowEventData*
    ptr_ShowEventData()
    {
        return (&(mVShowEventData));
    }
    const ShowEventData*
    constptr_ShowEventData() const
    {
        return (&(mVShowEventData));
    }
    HideEventData*
    ptr_HideEventData()
    {
        return (&(mVHideEventData));
    }
    const HideEventData*
    constptr_HideEventData() const
    {
        return (&(mVHideEventData));
    }
    ReorderEventData*
    ptr_ReorderEventData()
    {
        return (&(mVReorderEventData));
    }
    const ReorderEventData*
    constptr_ReorderEventData() const
    {
        return (&(mVReorderEventData));
    }
    TextChangeEventData*
    ptr_TextChangeEventData()
    {
        return (&(mVTextChangeEventData));
    }
    const TextChangeEventData*
    constptr_TextChangeEventData() const
    {
        return (&(mVTextChangeEventData));
    }

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

    MOZ_IMPLICIT MutationEventData(const CacheEventData& aOther);

    MOZ_IMPLICIT MutationEventData(CacheEventData&& aOther);

    MOZ_IMPLICIT MutationEventData(const ShowEventData& aOther);

    MOZ_IMPLICIT MutationEventData(ShowEventData&& aOther);

    MOZ_IMPLICIT MutationEventData(const HideEventData& aOther);

    MOZ_IMPLICIT MutationEventData(HideEventData&& aOther);

    MOZ_IMPLICIT MutationEventData(const ReorderEventData& aOther);

    MOZ_IMPLICIT MutationEventData(ReorderEventData&& aOther);

    MOZ_IMPLICIT MutationEventData(const TextChangeEventData& aOther);

    MOZ_IMPLICIT MutationEventData(TextChangeEventData&& aOther);

    MOZ_IMPLICIT MutationEventData(const MutationEventData& aOther);

    MOZ_IMPLICIT MutationEventData(MutationEventData&& aOther);

    ~MutationEventData();

    Type
    type() const
    {
        return mType;
    }

    MutationEventData&
    operator=(const CacheEventData& aRhs);

    MutationEventData&
    operator=(CacheEventData&& aRhs);

    MutationEventData&
    operator=(const ShowEventData& aRhs);

    MutationEventData&
    operator=(ShowEventData&& aRhs);

    MutationEventData&
    operator=(const HideEventData& aRhs);

    MutationEventData&
    operator=(HideEventData&& aRhs);

    MutationEventData&
    operator=(const ReorderEventData& aRhs);

    MutationEventData&
    operator=(ReorderEventData&& aRhs);

    MutationEventData&
    operator=(const TextChangeEventData& aRhs);

    MutationEventData&
    operator=(TextChangeEventData&& aRhs);

    MutationEventData&
    operator=(const MutationEventData& aRhs);

    MutationEventData&
    operator=(MutationEventData&& aRhs);

    CacheEventData&
    get_CacheEventData()
    {
        AssertSanity(TCacheEventData);
        return (*(ptr_CacheEventData()));
    }
    const CacheEventData&
    get_CacheEventData() const
    {
        AssertSanity(TCacheEventData);
        return (*(constptr_CacheEventData()));
    }
    operator CacheEventData&()
    {
        return get_CacheEventData();
    }
    operator const CacheEventData&() const
    {
        return get_CacheEventData();
    }

    ShowEventData&
    get_ShowEventData()
    {
        AssertSanity(TShowEventData);
        return (*(ptr_ShowEventData()));
    }
    const ShowEventData&
    get_ShowEventData() const
    {
        AssertSanity(TShowEventData);
        return (*(constptr_ShowEventData()));
    }
    operator ShowEventData&()
    {
        return get_ShowEventData();
    }
    operator const ShowEventData&() const
    {
        return get_ShowEventData();
    }

    HideEventData&
    get_HideEventData()
    {
        AssertSanity(THideEventData);
        return (*(ptr_HideEventData()));
    }
    const HideEventData&
    get_HideEventData() const
    {
        AssertSanity(THideEventData);
        return (*(constptr_HideEventData()));
    }
    operator HideEventData&()
    {
        return get_HideEventData();
    }
    operator const HideEventData&() const
    {
        return get_HideEventData();
    }

    ReorderEventData&
    get_ReorderEventData()
    {
        AssertSanity(TReorderEventData);
        return (*(ptr_ReorderEventData()));
    }
    const ReorderEventData&
    get_ReorderEventData() const
    {
        AssertSanity(TReorderEventData);
        return (*(constptr_ReorderEventData()));
    }
    operator ReorderEventData&()
    {
        return get_ReorderEventData();
    }
    operator const ReorderEventData&() const
    {
        return get_ReorderEventData();
    }

    TextChangeEventData&
    get_TextChangeEventData()
    {
        AssertSanity(TTextChangeEventData);
        return (*(ptr_TextChangeEventData()));
    }
    const TextChangeEventData&
    get_TextChangeEventData() const
    {
        AssertSanity(TTextChangeEventData);
        return (*(constptr_TextChangeEventData()));
    }
    operator TextChangeEventData&()
    {
        return get_TextChangeEventData();
    }
    operator const TextChangeEventData&() const
    {
        return get_TextChangeEventData();
    }

private:
    union {
        CacheEventData mVCacheEventData;
        ShowEventData mVShowEventData;
        HideEventData mVHideEventData;
        ReorderEventData mVReorderEventData;
        TextChangeEventData mVTextChangeEventData;
    };
    Type mType;
};
} // namespace a11y
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::a11y::MutationEventData>
{
    typedef ::mozilla::a11y::MutationEventData 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 TextRangeData|
//
namespace mozilla {
namespace a11y {
class TextRangeData final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::int32_t int32_t;

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

    MOZ_IMPLICIT TextRangeData(
            const uint64_t& _StartID,
            const uint64_t& _EndID,
            const int32_t& _StartOffset,
            const int32_t& _EndOffset) :
        StartID_(_StartID),
        EndID_(_EndID),
        StartOffset_(_StartOffset),
        EndOffset_(_EndOffset)
    {
    }

    MOZ_IMPLICIT TextRangeData(
            uint64_t&& _StartID,
            uint64_t&& _EndID,
            int32_t&& _StartOffset,
            int32_t&& _EndOffset) :
        StartID_(std::move(_StartID)),
        EndID_(std::move(_EndID)),
        StartOffset_(std::move(_StartOffset)),
        EndOffset_(std::move(_EndOffset))
    {
    }

    uint64_t&
    StartID()
    {
        return StartID_;
    }
    const uint64_t&
    StartID() const
    {
        return StartID_;
    }

    uint64_t&
    EndID()
    {
        return EndID_;
    }
    const uint64_t&
    EndID() const
    {
        return EndID_;
    }

    int32_t&
    StartOffset()
    {
        return StartOffset_;
    }
    const int32_t&
    StartOffset() const
    {
        return StartOffset_;
    }

    int32_t&
    EndOffset()
    {
        return EndOffset_;
    }
    const int32_t&
    EndOffset() const
    {
        return EndOffset_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<uint64_t> StartID_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> EndID_;
    ::mozilla::ipc::IPDLStructMember<int32_t> StartOffset_;
    ::mozilla::ipc::IPDLStructMember<int32_t> EndOffset_;
};
} // namespace a11y
} // namespace mozilla

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

namespace mozilla {
namespace a11y {
class PDocAccessibleParent;
} // namespace a11y
} // namespace mozilla
namespace mozilla {
namespace a11y {
class PDocAccessibleChild;
} // namespace a11y
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PDocAccessibleChild and PDocAccessibleParent
//
namespace mozilla {
namespace a11y {
namespace PDocAccessible {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::a11y::PDocAccessibleParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::a11y::PDocAccessibleChild>* aChild);

enum MessageType {
    PDocAccessibleStart = PDocAccessibleMsgStart << 16,
    Msg_Shutdown__ID,
    Msg_Event__ID,
    Msg_StateChangeEvent__ID,
    Msg_CaretMoveEvent__ID,
    Msg_MutationEvents__ID,
    Msg_RequestAckMutationEvents__ID,
    Msg_SelectionEvent__ID,
    Msg_RoleChangedEvent__ID,
    Msg_FocusEvent__ID,
    Msg_ScrollingEvent__ID,
    Msg_AnnouncementEvent__ID,
    Msg_TextSelectionChangeEvent__ID,
    Msg_BindChildDoc__ID,
    Msg_Cache__ID,
    Msg_SelectedAccessiblesChanged__ID,
    Msg_AccessiblesWillMove__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    Msg_RestoreFocus__ID,
    Msg_ScrollTo__ID,
    Msg_ScrollToPoint__ID,
    Msg_Announce__ID,
    Msg_SetTextSelection__ID,
    Msg_RemoveTextSelection__ID,
    Msg_ScrollTextLeafRangeIntoView__ID,
    Msg_ScrollSubstringToPoint__ID,
    Msg_ReplaceText__ID,
    Msg_InsertText__ID,
    Msg_CopyText__ID,
    Msg_CutText__ID,
    Msg_DeleteText__ID,
    Msg_PasteText__ID,
    Msg_TakeSelection__ID,
    Msg_SetSelected__ID,
    Msg_DoActionAsync__ID,
    Msg_SetCurValue__ID,
    Msg_TakeFocus__ID,
    Msg_VerifyCache__ID,
    Msg_AckMutationEvents__ID,
    PDocAccessibleEnd
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mozilla::UniquePtr<IPC::Message>
Msg_AccessiblesWillMove(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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



} // namespace PDocAccessible
} // namespace a11y
} // namespace mozilla

#endif // ifndef PDocAccessible_h
