build/TelepathyQt/_gen/types.h

/* Generated from Telepathy D-Bus Interface Specification, TelepathyQt copy, version 0.17.7 */

#ifndef IN_TP_QT_HEADER
#error IN_TP_QT_HEADER
#endif

#include <QtGlobal>

#include <QByteArray>
#include <QString>
#include <QStringList>
#include <QVariantList>
#include <QVariantMap>

#include <QDBusArgument>
#include <QDBusMetaType>
#include <QDBusObjectPath>
#include <QDBusSignature>
#include <QDBusVariant>

#include <TelepathyQt/Global>

namespace Tp
{
struct TP_QT_EXPORT ByteArrayList : public QList<QByteArray>
{
    ByteArrayList() : QList<QByteArray>() {}
    ByteArrayList(const QList<QByteArray>& a) : QList<QByteArray>(a) {}
    ByteArrayList(std::initializer_list<QByteArray> a) : QList<QByteArray>(a) {}

    ByteArrayList& operator=(const QList<QByteArray>& a)
    {
        *(static_cast<QList<QByteArray>*>(this)) = a;
        return *this;
    }
};

TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ByteArrayList &list);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ByteArrayList &list);

struct TP_QT_EXPORT ObjectPathList : public QList<QDBusObjectPath>
{
    ObjectPathList() : QList<QDBusObjectPath>() {}
    ObjectPathList(const QList<QDBusObjectPath>& a) : QList<QDBusObjectPath>(a) {}
    ObjectPathList(std::initializer_list<QDBusObjectPath> a) : QList<QDBusObjectPath>(a) {}

    ObjectPathList& operator=(const QList<QDBusObjectPath>& a)
    {
        *(static_cast<QList<QDBusObjectPath>*>(this)) = a;
        return *this;
    }
};

TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ObjectPathList &list);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ObjectPathList &list);

struct TP_QT_EXPORT UIntList : public QList<uint>
{
    UIntList() : QList<uint>() {}
    UIntList(const QList<uint>& a) : QList<uint>(a) {}
    UIntList(std::initializer_list<uint> a) : QList<uint>(a) {}

    UIntList& operator=(const QList<uint>& a)
    {
        *(static_cast<QList<uint>*>(this)) = a;
        return *this;
    }
};

TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const UIntList &list);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, UIntList &list);

struct TP_QT_EXPORT AccessControl
{
    uint type;
    QDBusVariant detail;
};

TP_QT_EXPORT bool operator==(const AccessControl& v1, const AccessControl& v2);
inline bool operator!=(const AccessControl& v1, const AccessControl& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const AccessControl& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, AccessControl& val);

struct TP_QT_EXPORT AddressingNormalizationMap : public QMap<QString, uint>
{
    AddressingNormalizationMap() : QMap<QString, uint>() {}
    AddressingNormalizationMap(const QMap<QString, uint>& a) : QMap<QString, uint>(a) {}
    AddressingNormalizationMap(std::initializer_list<std::pair<QString, uint> > a) : QMap<QString, uint>(a) {}

    AddressingNormalizationMap& operator=(const QMap<QString, uint>& a)
    {
        *(static_cast<QMap<QString, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT AliasMap : public QMap<uint, QString>
{
    AliasMap() : QMap<uint, QString>() {}
    AliasMap(const QMap<uint, QString>& a) : QMap<uint, QString>(a) {}
    AliasMap(std::initializer_list<std::pair<uint, QString> > a) : QMap<uint, QString>(a) {}

    AliasMap& operator=(const QMap<uint, QString>& a)
    {
        *(static_cast<QMap<uint, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT AliasPair
{
    uint handle;
    QString alias;
};

TP_QT_EXPORT bool operator==(const AliasPair& v1, const AliasPair& v2);
inline bool operator!=(const AliasPair& v1, const AliasPair& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const AliasPair& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, AliasPair& val);

typedef QList<AliasPair> AliasPairList;

struct TP_QT_EXPORT Avatar
{
    QByteArray avatarData;
    QString MIMEType;
};

TP_QT_EXPORT bool operator==(const Avatar& v1, const Avatar& v2);
inline bool operator!=(const Avatar& v1, const Avatar& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const Avatar& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, Avatar& val);

struct TP_QT_EXPORT AvatarTokenMap : public QMap<uint, QString>
{
    AvatarTokenMap() : QMap<uint, QString>() {}
    AvatarTokenMap(const QMap<uint, QString>& a) : QMap<uint, QString>(a) {}
    AvatarTokenMap(std::initializer_list<std::pair<uint, QString> > a) : QMap<uint, QString>(a) {}

    AvatarTokenMap& operator=(const QMap<uint, QString>& a)
    {
        *(static_cast<QMap<uint, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT CallMemberMap : public QMap<uint, uint>
{
    CallMemberMap() : QMap<uint, uint>() {}
    CallMemberMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    CallMemberMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    CallMemberMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

typedef QList<CallMemberMap> CallMemberMapList;

struct TP_QT_EXPORT CallStateReason
{
    uint actor;
    uint reason;
    QString DBusReason;
    QString message;
};

TP_QT_EXPORT bool operator==(const CallStateReason& v1, const CallStateReason& v2);
inline bool operator!=(const CallStateReason& v1, const CallStateReason& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CallStateReason& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CallStateReason& val);

struct TP_QT_EXPORT Candidate
{
    uint component;
    QString IP;
    uint port;
    QVariantMap info;
};

TP_QT_EXPORT bool operator==(const Candidate& v1, const Candidate& v2);
inline bool operator!=(const Candidate& v1, const Candidate& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const Candidate& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, Candidate& val);

typedef QList<Candidate> CandidateList;

struct TP_QT_EXPORT CandidateInfo : public QMap<QString, QDBusVariant>
{
    CandidateInfo() : QMap<QString, QDBusVariant>() {}
    CandidateInfo(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    CandidateInfo(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    CandidateInfo& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT CapabilityChange
{
    uint handle;
    QString channelType;
    uint oldGenericFlags;
    uint newGenericFlags;
    uint oldTypeSpecificFlags;
    uint newTypeSpecificFlags;
};

TP_QT_EXPORT bool operator==(const CapabilityChange& v1, const CapabilityChange& v2);
inline bool operator!=(const CapabilityChange& v1, const CapabilityChange& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CapabilityChange& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CapabilityChange& val);

typedef QList<CapabilityChange> CapabilityChangeList;

struct TP_QT_EXPORT CapabilityPair
{
    QString channelType;
    uint typeSpecificFlags;
};

TP_QT_EXPORT bool operator==(const CapabilityPair& v1, const CapabilityPair& v2);
inline bool operator!=(const CapabilityPair& v1, const CapabilityPair& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CapabilityPair& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CapabilityPair& val);

typedef QList<CapabilityPair> CapabilityPairList;

struct TP_QT_EXPORT CaptchaAnswers : public QMap<uint, QString>
{
    CaptchaAnswers() : QMap<uint, QString>() {}
    CaptchaAnswers(const QMap<uint, QString>& a) : QMap<uint, QString>(a) {}
    CaptchaAnswers(std::initializer_list<std::pair<uint, QString> > a) : QMap<uint, QString>(a) {}

    CaptchaAnswers& operator=(const QMap<uint, QString>& a)
    {
        *(static_cast<QMap<uint, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT CaptchaInfo
{
    uint ID;
    QString type;
    QString label;
    uint flags;
    QStringList availableMIMETypes;
};

TP_QT_EXPORT bool operator==(const CaptchaInfo& v1, const CaptchaInfo& v2);
inline bool operator!=(const CaptchaInfo& v1, const CaptchaInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CaptchaInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CaptchaInfo& val);

typedef QList<CaptchaInfo> CaptchaInfoList;

struct TP_QT_EXPORT ChannelCallStateMap : public QMap<uint, uint>
{
    ChannelCallStateMap() : QMap<uint, uint>() {}
    ChannelCallStateMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    ChannelCallStateMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    ChannelCallStateMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ChannelClass : public QMap<QString, QDBusVariant>
{
    ChannelClass() : QMap<QString, QDBusVariant>() {}
    ChannelClass(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    ChannelClass(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    ChannelClass& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

typedef QList<ChannelClass> ChannelClassList;

struct TP_QT_EXPORT ChannelDetails
{
    QDBusObjectPath channel;
    QVariantMap properties;
};

TP_QT_EXPORT bool operator==(const ChannelDetails& v1, const ChannelDetails& v2);
inline bool operator!=(const ChannelDetails& v1, const ChannelDetails& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ChannelDetails& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ChannelDetails& val);

typedef QList<ChannelDetails> ChannelDetailsList;

struct TP_QT_EXPORT ChannelInfo
{
    QDBusObjectPath channel;
    QString channelType;
    uint handleType;
    uint handle;
};

TP_QT_EXPORT bool operator==(const ChannelInfo& v1, const ChannelInfo& v2);
inline bool operator!=(const ChannelInfo& v1, const ChannelInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ChannelInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ChannelInfo& val);

typedef QList<ChannelInfo> ChannelInfoList;

struct TP_QT_EXPORT ChannelOriginatorMap : public QMap<uint, QDBusObjectPath>
{
    ChannelOriginatorMap() : QMap<uint, QDBusObjectPath>() {}
    ChannelOriginatorMap(const QMap<uint, QDBusObjectPath>& a) : QMap<uint, QDBusObjectPath>(a) {}
    ChannelOriginatorMap(std::initializer_list<std::pair<uint, QDBusObjectPath> > a) : QMap<uint, QDBusObjectPath>(a) {}

    ChannelOriginatorMap& operator=(const QMap<uint, QDBusObjectPath>& a)
    {
        *(static_cast<QMap<uint, QDBusObjectPath>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ChatStateMap : public QMap<uint, uint>
{
    ChatStateMap() : QMap<uint, uint>() {}
    ChatStateMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    ChatStateMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    ChatStateMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ComponentStateMap : public QMap<uint, uint>
{
    ComponentStateMap() : QMap<uint, uint>() {}
    ComponentStateMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    ComponentStateMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    ComponentStateMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactAttributesMap : public QMap<uint, QVariantMap>
{
    ContactAttributesMap() : QMap<uint, QVariantMap>() {}
    ContactAttributesMap(const QMap<uint, QVariantMap>& a) : QMap<uint, QVariantMap>(a) {}
    ContactAttributesMap(std::initializer_list<std::pair<uint, QVariantMap> > a) : QMap<uint, QVariantMap>(a) {}

    ContactAttributesMap& operator=(const QMap<uint, QVariantMap>& a)
    {
        *(static_cast<QMap<uint, QVariantMap>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactCapability
{
    uint handle;
    QString channelType;
    uint genericFlags;
    uint typeSpecificFlags;
};

TP_QT_EXPORT bool operator==(const ContactCapability& v1, const ContactCapability& v2);
inline bool operator!=(const ContactCapability& v1, const ContactCapability& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ContactCapability& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ContactCapability& val);

typedef QList<ContactCapability> ContactCapabilityList;

struct TP_QT_EXPORT ContactClientTypes : public QMap<uint, QStringList>
{
    ContactClientTypes() : QMap<uint, QStringList>() {}
    ContactClientTypes(const QMap<uint, QStringList>& a) : QMap<uint, QStringList>(a) {}
    ContactClientTypes(std::initializer_list<std::pair<uint, QStringList> > a) : QMap<uint, QStringList>(a) {}

    ContactClientTypes& operator=(const QMap<uint, QStringList>& a)
    {
        *(static_cast<QMap<uint, QStringList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactInfoField
{
    QString fieldName;
    QStringList parameters;
    QStringList fieldValue;
};

TP_QT_EXPORT bool operator==(const ContactInfoField& v1, const ContactInfoField& v2);
inline bool operator!=(const ContactInfoField& v1, const ContactInfoField& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ContactInfoField& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ContactInfoField& val);

typedef QList<ContactInfoField> ContactInfoFieldList;

struct TP_QT_EXPORT ContactLocations : public QMap<uint, QVariantMap>
{
    ContactLocations() : QMap<uint, QVariantMap>() {}
    ContactLocations(const QMap<uint, QVariantMap>& a) : QMap<uint, QVariantMap>(a) {}
    ContactLocations(std::initializer_list<std::pair<uint, QVariantMap> > a) : QMap<uint, QVariantMap>(a) {}

    ContactLocations& operator=(const QMap<uint, QVariantMap>& a)
    {
        *(static_cast<QMap<uint, QVariantMap>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactMediaDescriptionPropertiesMap : public QMap<uint, QVariantMap>
{
    ContactMediaDescriptionPropertiesMap() : QMap<uint, QVariantMap>() {}
    ContactMediaDescriptionPropertiesMap(const QMap<uint, QVariantMap>& a) : QMap<uint, QVariantMap>(a) {}
    ContactMediaDescriptionPropertiesMap(std::initializer_list<std::pair<uint, QVariantMap> > a) : QMap<uint, QVariantMap>(a) {}

    ContactMediaDescriptionPropertiesMap& operator=(const QMap<uint, QVariantMap>& a)
    {
        *(static_cast<QMap<uint, QVariantMap>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSSRCsMap : public QMap<uint, UIntList>
{
    ContactSSRCsMap() : QMap<uint, UIntList>() {}
    ContactSSRCsMap(const QMap<uint, UIntList>& a) : QMap<uint, UIntList>(a) {}
    ContactSSRCsMap(std::initializer_list<std::pair<uint, UIntList> > a) : QMap<uint, UIntList>(a) {}

    ContactSSRCsMap& operator=(const QMap<uint, UIntList>& a)
    {
        *(static_cast<QMap<uint, UIntList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSearchMap : public QMap<QString, QString>
{
    ContactSearchMap() : QMap<QString, QString>() {}
    ContactSearchMap(const QMap<QString, QString>& a) : QMap<QString, QString>(a) {}
    ContactSearchMap(std::initializer_list<std::pair<QString, QString> > a) : QMap<QString, QString>(a) {}

    ContactSearchMap& operator=(const QMap<QString, QString>& a)
    {
        *(static_cast<QMap<QString, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSendingStateMap : public QMap<uint, uint>
{
    ContactSendingStateMap() : QMap<uint, uint>() {}
    ContactSendingStateMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    ContactSendingStateMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    ContactSendingStateMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSubscriptions
{
    uint subscribe;
    uint publish;
    QString publishRequest;
};

TP_QT_EXPORT bool operator==(const ContactSubscriptions& v1, const ContactSubscriptions& v2);
inline bool operator!=(const ContactSubscriptions& v1, const ContactSubscriptions& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ContactSubscriptions& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ContactSubscriptions& val);

struct TP_QT_EXPORT CurrencyAmount
{
    int amount;
    uint scale;
    QString currency;
};

TP_QT_EXPORT bool operator==(const CurrencyAmount& v1, const CurrencyAmount& v2);
inline bool operator!=(const CurrencyAmount& v1, const CurrencyAmount& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CurrencyAmount& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CurrencyAmount& val);

struct TP_QT_EXPORT DBusTubeMember
{
    uint handle;
    QString uniqueName;
};

TP_QT_EXPORT bool operator==(const DBusTubeMember& v1, const DBusTubeMember& v2);
inline bool operator!=(const DBusTubeMember& v1, const DBusTubeMember& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const DBusTubeMember& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, DBusTubeMember& val);

typedef QList<DBusTubeMember> DBusTubeMemberList;

struct TP_QT_EXPORT DBusTubeParticipants : public QMap<uint, QString>
{
    DBusTubeParticipants() : QMap<uint, QString>() {}
    DBusTubeParticipants(const QMap<uint, QString>& a) : QMap<uint, QString>(a) {}
    DBusTubeParticipants(std::initializer_list<std::pair<uint, QString> > a) : QMap<uint, QString>(a) {}

    DBusTubeParticipants& operator=(const QMap<uint, QString>& a)
    {
        *(static_cast<QMap<uint, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT DebugMessage
{
    double timestamp;
    QString domain;
    uint level;
    QString message;
};

TP_QT_EXPORT bool operator==(const DebugMessage& v1, const DebugMessage& v2);
inline bool operator!=(const DebugMessage& v1, const DebugMessage& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const DebugMessage& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, DebugMessage& val);

typedef QList<DebugMessage> DebugMessageList;

struct TP_QT_EXPORT FieldSpec
{
    QString name;
    QStringList parameters;
    uint flags;
    uint max;
};

TP_QT_EXPORT bool operator==(const FieldSpec& v1, const FieldSpec& v2);
inline bool operator!=(const FieldSpec& v1, const FieldSpec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const FieldSpec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, FieldSpec& val);

typedef QList<FieldSpec> FieldSpecs;

struct TP_QT_EXPORT HTTPPostData
{
    QString key;
    QString value;
};

TP_QT_EXPORT bool operator==(const HTTPPostData& v1, const HTTPPostData& v2);
inline bool operator!=(const HTTPPostData& v1, const HTTPPostData& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const HTTPPostData& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, HTTPPostData& val);

typedef QList<HTTPPostData> HTTPPostDataList;

struct TP_QT_EXPORT HandleIdentifierMap : public QMap<uint, QString>
{
    HandleIdentifierMap() : QMap<uint, QString>() {}
    HandleIdentifierMap(const QMap<uint, QString>& a) : QMap<uint, QString>(a) {}
    HandleIdentifierMap(std::initializer_list<std::pair<uint, QString> > a) : QMap<uint, QString>(a) {}

    HandleIdentifierMap& operator=(const QMap<uint, QString>& a)
    {
        *(static_cast<QMap<uint, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT HandleOwnerMap : public QMap<uint, uint>
{
    HandleOwnerMap() : QMap<uint, uint>() {}
    HandleOwnerMap(const QMap<uint, uint>& a) : QMap<uint, uint>(a) {}
    HandleOwnerMap(std::initializer_list<std::pair<uint, uint> > a) : QMap<uint, uint>(a) {}

    HandleOwnerMap& operator=(const QMap<uint, uint>& a)
    {
        *(static_cast<QMap<uint, uint>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT LocalPendingInfo
{
    uint toBeAdded;
    uint actor;
    uint reason;
    QString message;
};

TP_QT_EXPORT bool operator==(const LocalPendingInfo& v1, const LocalPendingInfo& v2);
inline bool operator!=(const LocalPendingInfo& v1, const LocalPendingInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const LocalPendingInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, LocalPendingInfo& val);

typedef QList<LocalPendingInfo> LocalPendingInfoList;

struct TP_QT_EXPORT Location : public QMap<QString, QDBusVariant>
{
    Location() : QMap<QString, QDBusVariant>() {}
    Location(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    Location(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    Location& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT Mail : public QMap<QString, QDBusVariant>
{
    Mail() : QMap<QString, QDBusVariant>() {}
    Mail(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    Mail(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    Mail& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

typedef QList<Mail> MailList;

struct TP_QT_EXPORT MailAddress
{
    QString name;
    QString address;
};

TP_QT_EXPORT bool operator==(const MailAddress& v1, const MailAddress& v2);
inline bool operator!=(const MailAddress& v1, const MailAddress& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MailAddress& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MailAddress& val);

typedef QList<MailAddress> MailAddressList;

struct TP_QT_EXPORT MediaDescriptionOffer
{
    QDBusObjectPath mediaDescription;
    QVariantMap properties;
};

TP_QT_EXPORT bool operator==(const MediaDescriptionOffer& v1, const MediaDescriptionOffer& v2);
inline bool operator!=(const MediaDescriptionOffer& v1, const MediaDescriptionOffer& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaDescriptionOffer& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaDescriptionOffer& val);

struct TP_QT_EXPORT MediaDescriptionProperties : public QMap<QString, QDBusVariant>
{
    MediaDescriptionProperties() : QMap<QString, QDBusVariant>() {}
    MediaDescriptionProperties(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    MediaDescriptionProperties(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    MediaDescriptionProperties& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT MediaSessionHandlerInfo
{
    QDBusObjectPath sessionHandler;
    QString mediaSessionType;
};

TP_QT_EXPORT bool operator==(const MediaSessionHandlerInfo& v1, const MediaSessionHandlerInfo& v2);
inline bool operator!=(const MediaSessionHandlerInfo& v1, const MediaSessionHandlerInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaSessionHandlerInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaSessionHandlerInfo& val);

typedef QList<MediaSessionHandlerInfo> MediaSessionHandlerInfoList;

struct TP_QT_EXPORT MediaStreamHandlerTransport
{
    uint componentNumber;
    QString IPAddress;
    uint port;
    uint protocol;
    QString subtype;
    QString profile;
    double preferenceValue;
    uint transportType;
    QString username;
    QString password;
};

TP_QT_EXPORT bool operator==(const MediaStreamHandlerTransport& v1, const MediaStreamHandlerTransport& v2);
inline bool operator!=(const MediaStreamHandlerTransport& v1, const MediaStreamHandlerTransport& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaStreamHandlerTransport& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaStreamHandlerTransport& val);

typedef QList<MediaStreamHandlerTransport> MediaStreamHandlerTransportList;

struct TP_QT_EXPORT MediaStreamInfo
{
    uint identifier;
    uint contact;
    uint type;
    uint state;
    uint direction;
    uint pendingSendFlags;
};

TP_QT_EXPORT bool operator==(const MediaStreamInfo& v1, const MediaStreamInfo& v2);
inline bool operator!=(const MediaStreamInfo& v1, const MediaStreamInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaStreamInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaStreamInfo& val);

typedef QList<MediaStreamInfo> MediaStreamInfoList;

struct TP_QT_EXPORT MessagePart : public QMap<QString, QDBusVariant>
{
    MessagePart() : QMap<QString, QDBusVariant>() {}
    MessagePart(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    MessagePart(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    MessagePart& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

typedef QList<MessagePart> MessagePartList;

typedef QList<MessagePartList> MessagePartListList;

struct TP_QT_EXPORT MessagePartContentMap : public QMap<uint, QDBusVariant>
{
    MessagePartContentMap() : QMap<uint, QDBusVariant>() {}
    MessagePartContentMap(const QMap<uint, QDBusVariant>& a) : QMap<uint, QDBusVariant>(a) {}
    MessagePartContentMap(std::initializer_list<std::pair<uint, QDBusVariant> > a) : QMap<uint, QDBusVariant>(a) {}

    MessagePartContentMap& operator=(const QMap<uint, QDBusVariant>& a)
    {
        *(static_cast<QMap<uint, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT Metadata : public QMap<QString, QStringList>
{
    Metadata() : QMap<QString, QStringList>() {}
    Metadata(const QMap<QString, QStringList>& a) : QMap<QString, QStringList>(a) {}
    Metadata(std::initializer_list<std::pair<QString, QStringList> > a) : QMap<QString, QStringList>(a) {}

    Metadata& operator=(const QMap<QString, QStringList>& a)
    {
        *(static_cast<QMap<QString, QStringList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT MultipleStatusMap : public QMap<QString, QVariantMap>
{
    MultipleStatusMap() : QMap<QString, QVariantMap>() {}
    MultipleStatusMap(const QMap<QString, QVariantMap>& a) : QMap<QString, QVariantMap>(a) {}
    MultipleStatusMap(std::initializer_list<std::pair<QString, QVariantMap> > a) : QMap<QString, QVariantMap>(a) {}

    MultipleStatusMap& operator=(const QMap<QString, QVariantMap>& a)
    {
        *(static_cast<QMap<QString, QVariantMap>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT NotDelegatedError
{
    QString errorName;
    QString errorMessage;
};

TP_QT_EXPORT bool operator==(const NotDelegatedError& v1, const NotDelegatedError& v2);
inline bool operator!=(const NotDelegatedError& v1, const NotDelegatedError& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const NotDelegatedError& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, NotDelegatedError& val);

struct TP_QT_EXPORT ObjectImmutablePropertiesMap : public QMap<QDBusObjectPath, QVariantMap>
{
    ObjectImmutablePropertiesMap() : QMap<QDBusObjectPath, QVariantMap>() {}
    ObjectImmutablePropertiesMap(const QMap<QDBusObjectPath, QVariantMap>& a) : QMap<QDBusObjectPath, QVariantMap>(a) {}
    ObjectImmutablePropertiesMap(std::initializer_list<std::pair<QDBusObjectPath, QVariantMap> > a) : QMap<QDBusObjectPath, QVariantMap>(a) {}

    ObjectImmutablePropertiesMap& operator=(const QMap<QDBusObjectPath, QVariantMap>& a)
    {
        *(static_cast<QMap<QDBusObjectPath, QVariantMap>*>(this)) = a;
        return *this;
    }
};

typedef QList<ObjectImmutablePropertiesMap> ObjectImmutablePropertiesMapList;

struct TP_QT_EXPORT ParamSpec
{
    QString name;
    uint flags;
    QString signature;
    QDBusVariant defaultValue;
};

TP_QT_EXPORT bool operator==(const ParamSpec& v1, const ParamSpec& v2);
inline bool operator!=(const ParamSpec& v1, const ParamSpec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ParamSpec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ParamSpec& val);

typedef QList<ParamSpec> ParamSpecList;

struct TP_QT_EXPORT PendingTextMessage
{
    uint identifier;
    uint unixTimestamp;
    uint sender;
    uint messageType;
    uint flags;
    QString text;
};

TP_QT_EXPORT bool operator==(const PendingTextMessage& v1, const PendingTextMessage& v2);
inline bool operator!=(const PendingTextMessage& v1, const PendingTextMessage& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const PendingTextMessage& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, PendingTextMessage& val);

typedef QList<PendingTextMessage> PendingTextMessageList;

struct TP_QT_EXPORT PropertyFlagsChange
{
    uint propertyID;
    uint newFlags;
};

TP_QT_EXPORT bool operator==(const PropertyFlagsChange& v1, const PropertyFlagsChange& v2);
inline bool operator!=(const PropertyFlagsChange& v1, const PropertyFlagsChange& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const PropertyFlagsChange& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, PropertyFlagsChange& val);

typedef QList<PropertyFlagsChange> PropertyFlagsChangeList;

struct TP_QT_EXPORT PropertySpec
{
    uint propertyID;
    QString name;
    QString signature;
    uint flags;
};

TP_QT_EXPORT bool operator==(const PropertySpec& v1, const PropertySpec& v2);
inline bool operator!=(const PropertySpec& v1, const PropertySpec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const PropertySpec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, PropertySpec& val);

typedef QList<PropertySpec> PropertySpecList;

struct TP_QT_EXPORT PropertyValue
{
    uint identifier;
    QDBusVariant value;
};

TP_QT_EXPORT bool operator==(const PropertyValue& v1, const PropertyValue& v2);
inline bool operator!=(const PropertyValue& v1, const PropertyValue& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const PropertyValue& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, PropertyValue& val);

typedef QList<PropertyValue> PropertyValueList;

struct TP_QT_EXPORT ProtocolPropertiesMap : public QMap<QString, QVariantMap>
{
    ProtocolPropertiesMap() : QMap<QString, QVariantMap>() {}
    ProtocolPropertiesMap(const QMap<QString, QVariantMap>& a) : QMap<QString, QVariantMap>(a) {}
    ProtocolPropertiesMap(std::initializer_list<std::pair<QString, QVariantMap> > a) : QMap<QString, QVariantMap>(a) {}

    ProtocolPropertiesMap& operator=(const QMap<QString, QVariantMap>& a)
    {
        *(static_cast<QMap<QString, QVariantMap>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT QualifiedPropertyValueMap : public QMap<QString, QDBusVariant>
{
    QualifiedPropertyValueMap() : QMap<QString, QDBusVariant>() {}
    QualifiedPropertyValueMap(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    QualifiedPropertyValueMap(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    QualifiedPropertyValueMap& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

typedef QList<QualifiedPropertyValueMap> QualifiedPropertyValueMapList;

struct TP_QT_EXPORT RTCPFeedbackMessage
{
    QString type;
    QString subtype;
    QString parameters;
};

TP_QT_EXPORT bool operator==(const RTCPFeedbackMessage& v1, const RTCPFeedbackMessage& v2);
inline bool operator!=(const RTCPFeedbackMessage& v1, const RTCPFeedbackMessage& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RTCPFeedbackMessage& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RTCPFeedbackMessage& val);

typedef QList<RTCPFeedbackMessage> RTCPFeedbackMessageList;

struct TP_QT_EXPORT RTPHeaderExtension
{
    uint ID;
    uint direction;
    QString URI;
    QString parameters;
};

TP_QT_EXPORT bool operator==(const RTPHeaderExtension& v1, const RTPHeaderExtension& v2);
inline bool operator!=(const RTPHeaderExtension& v1, const RTPHeaderExtension& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RTPHeaderExtension& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RTPHeaderExtension& val);

typedef QList<RTPHeaderExtension> RTPHeaderExtensionsList;

struct TP_QT_EXPORT RequestableChannelClass
{
    QVariantMap fixedProperties;
    QStringList allowedProperties;
};

TP_QT_EXPORT bool operator==(const RequestableChannelClass& v1, const RequestableChannelClass& v2);
inline bool operator!=(const RequestableChannelClass& v1, const RequestableChannelClass& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RequestableChannelClass& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RequestableChannelClass& val);

typedef QList<RequestableChannelClass> RequestableChannelClassList;

struct TP_QT_EXPORT RichPresenceAccessControl
{
    uint type;
    QDBusVariant detail;
};

TP_QT_EXPORT bool operator==(const RichPresenceAccessControl& v1, const RichPresenceAccessControl& v2);
inline bool operator!=(const RichPresenceAccessControl& v1, const RichPresenceAccessControl& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RichPresenceAccessControl& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RichPresenceAccessControl& val);

struct TP_QT_EXPORT RoomInfo
{
    uint handle;
    QString channelType;
    QVariantMap info;
};

TP_QT_EXPORT bool operator==(const RoomInfo& v1, const RoomInfo& v2);
inline bool operator!=(const RoomInfo& v1, const RoomInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RoomInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RoomInfo& val);

typedef QList<RoomInfo> RoomInfoList;

struct TP_QT_EXPORT ServicePoint
{
    uint servicePointType;
    QString service;
};

TP_QT_EXPORT bool operator==(const ServicePoint& v1, const ServicePoint& v2);
inline bool operator!=(const ServicePoint& v1, const ServicePoint& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ServicePoint& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ServicePoint& val);

struct TP_QT_EXPORT SimplePresence
{
    uint type;
    QString status;
    QString statusMessage;
};

TP_QT_EXPORT bool operator==(const SimplePresence& v1, const SimplePresence& v2);
inline bool operator!=(const SimplePresence& v1, const SimplePresence& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SimplePresence& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SimplePresence& val);

struct TP_QT_EXPORT SimpleStatusSpec
{
    uint type;
    bool maySetOnSelf;
    bool canHaveMessage;
};

TP_QT_EXPORT bool operator==(const SimpleStatusSpec& v1, const SimpleStatusSpec& v2);
inline bool operator!=(const SimpleStatusSpec& v1, const SimpleStatusSpec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SimpleStatusSpec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SimpleStatusSpec& val);

struct TP_QT_EXPORT SingleContactAttributesMap : public QMap<QString, QDBusVariant>
{
    SingleContactAttributesMap() : QMap<QString, QDBusVariant>() {}
    SingleContactAttributesMap(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    SingleContactAttributesMap(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    SingleContactAttributesMap& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT SocketAddressIP
{
    QString address;
    ushort port;
};

TP_QT_EXPORT bool operator==(const SocketAddressIP& v1, const SocketAddressIP& v2);
inline bool operator!=(const SocketAddressIP& v1, const SocketAddressIP& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SocketAddressIP& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SocketAddressIP& val);

typedef QList<SocketAddressIP> SocketAddressIPList;

struct TP_QT_EXPORT SocketAddressIPv4
{
    QString address;
    ushort port;
};

TP_QT_EXPORT bool operator==(const SocketAddressIPv4& v1, const SocketAddressIPv4& v2);
inline bool operator!=(const SocketAddressIPv4& v1, const SocketAddressIPv4& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SocketAddressIPv4& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SocketAddressIPv4& val);

struct TP_QT_EXPORT SocketAddressIPv6
{
    QString address;
    ushort port;
};

TP_QT_EXPORT bool operator==(const SocketAddressIPv6& v1, const SocketAddressIPv6& v2);
inline bool operator!=(const SocketAddressIPv6& v1, const SocketAddressIPv6& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SocketAddressIPv6& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SocketAddressIPv6& val);

struct TP_QT_EXPORT SocketNetmaskIPv4
{
    QString address;
    uchar prefixLength;
};

TP_QT_EXPORT bool operator==(const SocketNetmaskIPv4& v1, const SocketNetmaskIPv4& v2);
inline bool operator!=(const SocketNetmaskIPv4& v1, const SocketNetmaskIPv4& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SocketNetmaskIPv4& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SocketNetmaskIPv4& val);

struct TP_QT_EXPORT SocketNetmaskIPv6
{
    QString address;
    uchar prefixLength;
};

TP_QT_EXPORT bool operator==(const SocketNetmaskIPv6& v1, const SocketNetmaskIPv6& v2);
inline bool operator!=(const SocketNetmaskIPv6& v1, const SocketNetmaskIPv6& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const SocketNetmaskIPv6& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, SocketNetmaskIPv6& val);

struct TP_QT_EXPORT StreamCredentials
{
    QString username;
    QString password;
};

TP_QT_EXPORT bool operator==(const StreamCredentials& v1, const StreamCredentials& v2);
inline bool operator!=(const StreamCredentials& v1, const StreamCredentials& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const StreamCredentials& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, StreamCredentials& val);

struct TP_QT_EXPORT StringStringMap : public QMap<QString, QString>
{
    StringStringMap() : QMap<QString, QString>() {}
    StringStringMap(const QMap<QString, QString>& a) : QMap<QString, QString>(a) {}
    StringStringMap(std::initializer_list<std::pair<QString, QString> > a) : QMap<QString, QString>(a) {}

    StringStringMap& operator=(const QMap<QString, QString>& a)
    {
        *(static_cast<QMap<QString, QString>*>(this)) = a;
        return *this;
    }
};

typedef QList<StringStringMap> StringStringMapList;

struct TP_QT_EXPORT StringVariantMap : public QMap<QString, QDBusVariant>
{
    StringVariantMap() : QMap<QString, QDBusVariant>() {}
    StringVariantMap(const QMap<QString, QDBusVariant>& a) : QMap<QString, QDBusVariant>(a) {}
    StringVariantMap(std::initializer_list<std::pair<QString, QDBusVariant> > a) : QMap<QString, QDBusVariant>(a) {}

    StringVariantMap& operator=(const QMap<QString, QDBusVariant>& a)
    {
        *(static_cast<QMap<QString, QDBusVariant>*>(this)) = a;
        return *this;
    }
};

typedef QList<StringVariantMap> StringVariantMapList;

struct TP_QT_EXPORT SupportedSocketMap : public QMap<uint, UIntList>
{
    SupportedSocketMap() : QMap<uint, UIntList>() {}
    SupportedSocketMap(const QMap<uint, UIntList>& a) : QMap<uint, UIntList>(a) {}
    SupportedSocketMap(std::initializer_list<std::pair<uint, UIntList> > a) : QMap<uint, UIntList>(a) {}

    SupportedSocketMap& operator=(const QMap<uint, UIntList>& a)
    {
        *(static_cast<QMap<uint, UIntList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT TLSCertificateRejection
{
    uint reason;
    QString error;
    QVariantMap details;
};

TP_QT_EXPORT bool operator==(const TLSCertificateRejection& v1, const TLSCertificateRejection& v2);
inline bool operator!=(const TLSCertificateRejection& v1, const TLSCertificateRejection& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const TLSCertificateRejection& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, TLSCertificateRejection& val);

typedef QList<TLSCertificateRejection> TLSCertificateRejectionList;

struct TP_QT_EXPORT TubeInfo
{
    uint identifier;
    uint initiator;
    uint type;
    QString service;
    QVariantMap parameters;
    uint state;
};

TP_QT_EXPORT bool operator==(const TubeInfo& v1, const TubeInfo& v2);
inline bool operator!=(const TubeInfo& v1, const TubeInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const TubeInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, TubeInfo& val);

typedef QList<TubeInfo> TubeInfoList;

struct TP_QT_EXPORT VCardFieldAddressMap : public QMap<QString, QString>
{
    VCardFieldAddressMap() : QMap<QString, QString>() {}
    VCardFieldAddressMap(const QMap<QString, QString>& a) : QMap<QString, QString>(a) {}
    VCardFieldAddressMap(std::initializer_list<std::pair<QString, QString> > a) : QMap<QString, QString>(a) {}

    VCardFieldAddressMap& operator=(const QMap<QString, QString>& a)
    {
        *(static_cast<QMap<QString, QString>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT VideoResolution
{
    uint width;
    uint height;
};

TP_QT_EXPORT bool operator==(const VideoResolution& v1, const VideoResolution& v2);
inline bool operator!=(const VideoResolution& v1, const VideoResolution& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const VideoResolution& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, VideoResolution& val);

typedef QList<VideoResolution> VideoResolutionStruct;

struct TP_QT_EXPORT CandidatePair
{
    Candidate local;
    Candidate remote;
};

TP_QT_EXPORT bool operator==(const CandidatePair& v1, const CandidatePair& v2);
inline bool operator!=(const CandidatePair& v1, const CandidatePair& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const CandidatePair& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, CandidatePair& val);

typedef QList<CandidatePair> CandidatePairList;

struct TP_QT_EXPORT Codec
{
    uint identifier;
    QString name;
    uint clockrate;
    uint channels;
    bool updated;
    StringStringMap parameters;
};

TP_QT_EXPORT bool operator==(const Codec& v1, const Codec& v2);
inline bool operator!=(const Codec& v1, const Codec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const Codec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, Codec& val);

typedef QList<Codec> CodecList;

struct TP_QT_EXPORT ContactCapabilitiesMap : public QMap<uint, RequestableChannelClassList>
{
    ContactCapabilitiesMap() : QMap<uint, RequestableChannelClassList>() {}
    ContactCapabilitiesMap(const QMap<uint, RequestableChannelClassList>& a) : QMap<uint, RequestableChannelClassList>(a) {}
    ContactCapabilitiesMap(std::initializer_list<std::pair<uint, RequestableChannelClassList> > a) : QMap<uint, RequestableChannelClassList>(a) {}

    ContactCapabilitiesMap& operator=(const QMap<uint, RequestableChannelClassList>& a)
    {
        *(static_cast<QMap<uint, RequestableChannelClassList>*>(this)) = a;
        return *this;
    }
};

typedef QList<ContactCapabilitiesMap> ContactCapabilitiesMapList;

struct TP_QT_EXPORT ContactInfoMap : public QMap<uint, ContactInfoFieldList>
{
    ContactInfoMap() : QMap<uint, ContactInfoFieldList>() {}
    ContactInfoMap(const QMap<uint, ContactInfoFieldList>& a) : QMap<uint, ContactInfoFieldList>(a) {}
    ContactInfoMap(std::initializer_list<std::pair<uint, ContactInfoFieldList> > a) : QMap<uint, ContactInfoFieldList>(a) {}

    ContactInfoMap& operator=(const QMap<uint, ContactInfoFieldList>& a)
    {
        *(static_cast<QMap<uint, ContactInfoFieldList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSearchResultMap : public QMap<QString, ContactInfoFieldList>
{
    ContactSearchResultMap() : QMap<QString, ContactInfoFieldList>() {}
    ContactSearchResultMap(const QMap<QString, ContactInfoFieldList>& a) : QMap<QString, ContactInfoFieldList>(a) {}
    ContactSearchResultMap(std::initializer_list<std::pair<QString, ContactInfoFieldList> > a) : QMap<QString, ContactInfoFieldList>(a) {}

    ContactSearchResultMap& operator=(const QMap<QString, ContactInfoFieldList>& a)
    {
        *(static_cast<QMap<QString, ContactInfoFieldList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactSubscriptionMap : public QMap<uint, ContactSubscriptions>
{
    ContactSubscriptionMap() : QMap<uint, ContactSubscriptions>() {}
    ContactSubscriptionMap(const QMap<uint, ContactSubscriptions>& a) : QMap<uint, ContactSubscriptions>(a) {}
    ContactSubscriptionMap(std::initializer_list<std::pair<uint, ContactSubscriptions> > a) : QMap<uint, ContactSubscriptions>(a) {}

    ContactSubscriptionMap& operator=(const QMap<uint, ContactSubscriptions>& a)
    {
        *(static_cast<QMap<uint, ContactSubscriptions>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT HandlerCapabilities
{
    QString wellKnownName;
    StringVariantMapList channelClasses;
    QStringList capabilities;
};

TP_QT_EXPORT bool operator==(const HandlerCapabilities& v1, const HandlerCapabilities& v2);
inline bool operator!=(const HandlerCapabilities& v1, const HandlerCapabilities& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const HandlerCapabilities& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, HandlerCapabilities& val);

typedef QList<HandlerCapabilities> HandlerCapabilitiesList;

struct TP_QT_EXPORT LastActivityAndStatuses
{
    uint lastActivity;
    MultipleStatusMap statuses;
};

TP_QT_EXPORT bool operator==(const LastActivityAndStatuses& v1, const LastActivityAndStatuses& v2);
inline bool operator!=(const LastActivityAndStatuses& v1, const LastActivityAndStatuses& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const LastActivityAndStatuses& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, LastActivityAndStatuses& val);

struct TP_QT_EXPORT MailURL
{
    QString URL;
    uint method;
    HTTPPostDataList postData;
};

TP_QT_EXPORT bool operator==(const MailURL& v1, const MailURL& v2);
inline bool operator!=(const MailURL& v1, const MailURL& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MailURL& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MailURL& val);

struct TP_QT_EXPORT MediaStreamHandlerCandidate
{
    QString name;
    MediaStreamHandlerTransportList transports;
};

TP_QT_EXPORT bool operator==(const MediaStreamHandlerCandidate& v1, const MediaStreamHandlerCandidate& v2);
inline bool operator!=(const MediaStreamHandlerCandidate& v1, const MediaStreamHandlerCandidate& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaStreamHandlerCandidate& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaStreamHandlerCandidate& val);

typedef QList<MediaStreamHandlerCandidate> MediaStreamHandlerCandidateList;

struct TP_QT_EXPORT MediaStreamHandlerCodec
{
    uint codecID;
    QString name;
    uint mediaType;
    uint clockRate;
    uint numberOfChannels;
    StringStringMap parameters;
};

TP_QT_EXPORT bool operator==(const MediaStreamHandlerCodec& v1, const MediaStreamHandlerCodec& v2);
inline bool operator!=(const MediaStreamHandlerCodec& v1, const MediaStreamHandlerCodec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const MediaStreamHandlerCodec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, MediaStreamHandlerCodec& val);

typedef QList<MediaStreamHandlerCodec> MediaStreamHandlerCodecList;

struct TP_QT_EXPORT NotDelegatedMap : public QMap<QDBusObjectPath, NotDelegatedError>
{
    NotDelegatedMap() : QMap<QDBusObjectPath, NotDelegatedError>() {}
    NotDelegatedMap(const QMap<QDBusObjectPath, NotDelegatedError>& a) : QMap<QDBusObjectPath, NotDelegatedError>(a) {}
    NotDelegatedMap(std::initializer_list<std::pair<QDBusObjectPath, NotDelegatedError> > a) : QMap<QDBusObjectPath, NotDelegatedError>(a) {}

    NotDelegatedMap& operator=(const QMap<QDBusObjectPath, NotDelegatedError>& a)
    {
        *(static_cast<QMap<QDBusObjectPath, NotDelegatedError>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT RTCPFeedbackMessageProperties
{
    uint RTCPMinimumInterval;
    RTCPFeedbackMessageList messages;
};

TP_QT_EXPORT bool operator==(const RTCPFeedbackMessageProperties& v1, const RTCPFeedbackMessageProperties& v2);
inline bool operator!=(const RTCPFeedbackMessageProperties& v1, const RTCPFeedbackMessageProperties& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const RTCPFeedbackMessageProperties& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, RTCPFeedbackMessageProperties& val);

struct TP_QT_EXPORT ServicePointInfo
{
    ServicePoint servicePoint;
    QStringList serviceIDs;
};

TP_QT_EXPORT bool operator==(const ServicePointInfo& v1, const ServicePointInfo& v2);
inline bool operator!=(const ServicePointInfo& v1, const ServicePointInfo& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const ServicePointInfo& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, ServicePointInfo& val);

typedef QList<ServicePointInfo> ServicePointInfoList;

struct TP_QT_EXPORT SimpleContactPresences : public QMap<uint, SimplePresence>
{
    SimpleContactPresences() : QMap<uint, SimplePresence>() {}
    SimpleContactPresences(const QMap<uint, SimplePresence>& a) : QMap<uint, SimplePresence>(a) {}
    SimpleContactPresences(std::initializer_list<std::pair<uint, SimplePresence> > a) : QMap<uint, SimplePresence>(a) {}

    SimpleContactPresences& operator=(const QMap<uint, SimplePresence>& a)
    {
        *(static_cast<QMap<uint, SimplePresence>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT SimpleStatusSpecMap : public QMap<QString, SimpleStatusSpec>
{
    SimpleStatusSpecMap() : QMap<QString, SimpleStatusSpec>() {}
    SimpleStatusSpecMap(const QMap<QString, SimpleStatusSpec>& a) : QMap<QString, SimpleStatusSpec>(a) {}
    SimpleStatusSpecMap(std::initializer_list<std::pair<QString, SimpleStatusSpec> > a) : QMap<QString, SimpleStatusSpec>(a) {}

    SimpleStatusSpecMap& operator=(const QMap<QString, SimpleStatusSpec>& a)
    {
        *(static_cast<QMap<QString, SimpleStatusSpec>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT StatusSpec
{
    uint type;
    bool maySetOnSelf;
    bool exclusive;
    StringStringMap parameterTypes;
};

TP_QT_EXPORT bool operator==(const StatusSpec& v1, const StatusSpec& v2);
inline bool operator!=(const StatusSpec& v1, const StatusSpec& v2)
{
    return !operator==(v1, v2);
}
TP_QT_EXPORT QDBusArgument& operator<<(QDBusArgument& arg, const StatusSpec& val);
TP_QT_EXPORT const QDBusArgument& operator>>(const QDBusArgument& arg, StatusSpec& val);

struct TP_QT_EXPORT ContactCodecMap : public QMap<uint, CodecList>
{
    ContactCodecMap() : QMap<uint, CodecList>() {}
    ContactCodecMap(const QMap<uint, CodecList>& a) : QMap<uint, CodecList>(a) {}
    ContactCodecMap(std::initializer_list<std::pair<uint, CodecList> > a) : QMap<uint, CodecList>(a) {}

    ContactCodecMap& operator=(const QMap<uint, CodecList>& a)
    {
        *(static_cast<QMap<uint, CodecList>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT ContactPresences : public QMap<uint, LastActivityAndStatuses>
{
    ContactPresences() : QMap<uint, LastActivityAndStatuses>() {}
    ContactPresences(const QMap<uint, LastActivityAndStatuses>& a) : QMap<uint, LastActivityAndStatuses>(a) {}
    ContactPresences(std::initializer_list<std::pair<uint, LastActivityAndStatuses> > a) : QMap<uint, LastActivityAndStatuses>(a) {}

    ContactPresences& operator=(const QMap<uint, LastActivityAndStatuses>& a)
    {
        *(static_cast<QMap<uint, LastActivityAndStatuses>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT RTCPFeedbackMessageMap : public QMap<uint, RTCPFeedbackMessageProperties>
{
    RTCPFeedbackMessageMap() : QMap<uint, RTCPFeedbackMessageProperties>() {}
    RTCPFeedbackMessageMap(const QMap<uint, RTCPFeedbackMessageProperties>& a) : QMap<uint, RTCPFeedbackMessageProperties>(a) {}
    RTCPFeedbackMessageMap(std::initializer_list<std::pair<uint, RTCPFeedbackMessageProperties> > a) : QMap<uint, RTCPFeedbackMessageProperties>(a) {}

    RTCPFeedbackMessageMap& operator=(const QMap<uint, RTCPFeedbackMessageProperties>& a)
    {
        *(static_cast<QMap<uint, RTCPFeedbackMessageProperties>*>(this)) = a;
        return *this;
    }
};

struct TP_QT_EXPORT StatusSpecMap : public QMap<QString, StatusSpec>
{
    StatusSpecMap() : QMap<QString, StatusSpec>() {}
    StatusSpecMap(const QMap<QString, StatusSpec>& a) : QMap<QString, StatusSpec>(a) {}
    StatusSpecMap(std::initializer_list<std::pair<QString, StatusSpec> > a) : QMap<QString, StatusSpec>(a) {}

    StatusSpecMap& operator=(const QMap<QString, StatusSpec>& a)
    {
        *(static_cast<QMap<QString, StatusSpec>*>(this)) = a;
        return *this;
    }
};


} // namespace Tp

Q_DECLARE_METATYPE(Tp::AccessControl)
Q_DECLARE_METATYPE(Tp::AddressingNormalizationMap)
Q_DECLARE_METATYPE(Tp::AliasMap)
Q_DECLARE_METATYPE(Tp::AliasPair)
Q_DECLARE_METATYPE(Tp::AliasPairList)
Q_DECLARE_METATYPE(Tp::Avatar)
Q_DECLARE_METATYPE(Tp::AvatarTokenMap)
Q_DECLARE_METATYPE(Tp::ByteArrayList)
Q_DECLARE_METATYPE(Tp::CallMemberMap)
Q_DECLARE_METATYPE(Tp::CallMemberMapList)
Q_DECLARE_METATYPE(Tp::CallStateReason)
Q_DECLARE_METATYPE(Tp::Candidate)
Q_DECLARE_METATYPE(Tp::CandidateInfo)
Q_DECLARE_METATYPE(Tp::CandidateList)
Q_DECLARE_METATYPE(Tp::CandidatePair)
Q_DECLARE_METATYPE(Tp::CandidatePairList)
Q_DECLARE_METATYPE(Tp::CapabilityChange)
Q_DECLARE_METATYPE(Tp::CapabilityChangeList)
Q_DECLARE_METATYPE(Tp::CapabilityPair)
Q_DECLARE_METATYPE(Tp::CapabilityPairList)
Q_DECLARE_METATYPE(Tp::CaptchaAnswers)
Q_DECLARE_METATYPE(Tp::CaptchaInfo)
Q_DECLARE_METATYPE(Tp::CaptchaInfoList)
Q_DECLARE_METATYPE(Tp::ChannelCallStateMap)
Q_DECLARE_METATYPE(Tp::ChannelClass)
Q_DECLARE_METATYPE(Tp::ChannelClassList)
Q_DECLARE_METATYPE(Tp::ChannelDetails)
Q_DECLARE_METATYPE(Tp::ChannelDetailsList)
Q_DECLARE_METATYPE(Tp::ChannelInfo)
Q_DECLARE_METATYPE(Tp::ChannelInfoList)
Q_DECLARE_METATYPE(Tp::ChannelOriginatorMap)
Q_DECLARE_METATYPE(Tp::ChatStateMap)
Q_DECLARE_METATYPE(Tp::Codec)
Q_DECLARE_METATYPE(Tp::CodecList)
Q_DECLARE_METATYPE(Tp::ComponentStateMap)
Q_DECLARE_METATYPE(Tp::ContactAttributesMap)
Q_DECLARE_METATYPE(Tp::ContactCapabilitiesMap)
Q_DECLARE_METATYPE(Tp::ContactCapabilitiesMapList)
Q_DECLARE_METATYPE(Tp::ContactCapability)
Q_DECLARE_METATYPE(Tp::ContactCapabilityList)
Q_DECLARE_METATYPE(Tp::ContactClientTypes)
Q_DECLARE_METATYPE(Tp::ContactCodecMap)
Q_DECLARE_METATYPE(Tp::ContactInfoField)
Q_DECLARE_METATYPE(Tp::ContactInfoFieldList)
Q_DECLARE_METATYPE(Tp::ContactInfoMap)
Q_DECLARE_METATYPE(Tp::ContactLocations)
Q_DECLARE_METATYPE(Tp::ContactMediaDescriptionPropertiesMap)
Q_DECLARE_METATYPE(Tp::ContactPresences)
Q_DECLARE_METATYPE(Tp::ContactSSRCsMap)
Q_DECLARE_METATYPE(Tp::ContactSearchMap)
Q_DECLARE_METATYPE(Tp::ContactSearchResultMap)
Q_DECLARE_METATYPE(Tp::ContactSendingStateMap)
Q_DECLARE_METATYPE(Tp::ContactSubscriptionMap)
Q_DECLARE_METATYPE(Tp::ContactSubscriptions)
Q_DECLARE_METATYPE(Tp::CurrencyAmount)
Q_DECLARE_METATYPE(Tp::DBusTubeMember)
Q_DECLARE_METATYPE(Tp::DBusTubeMemberList)
Q_DECLARE_METATYPE(Tp::DBusTubeParticipants)
Q_DECLARE_METATYPE(Tp::DebugMessage)
Q_DECLARE_METATYPE(Tp::DebugMessageList)
Q_DECLARE_METATYPE(Tp::FieldSpec)
Q_DECLARE_METATYPE(Tp::FieldSpecs)
Q_DECLARE_METATYPE(Tp::HTTPPostData)
Q_DECLARE_METATYPE(Tp::HTTPPostDataList)
Q_DECLARE_METATYPE(Tp::HandleIdentifierMap)
Q_DECLARE_METATYPE(Tp::HandleOwnerMap)
Q_DECLARE_METATYPE(Tp::HandlerCapabilities)
Q_DECLARE_METATYPE(Tp::HandlerCapabilitiesList)
Q_DECLARE_METATYPE(Tp::LastActivityAndStatuses)
Q_DECLARE_METATYPE(Tp::LocalPendingInfo)
Q_DECLARE_METATYPE(Tp::LocalPendingInfoList)
Q_DECLARE_METATYPE(Tp::Location)
Q_DECLARE_METATYPE(Tp::Mail)
Q_DECLARE_METATYPE(Tp::MailAddress)
Q_DECLARE_METATYPE(Tp::MailAddressList)
Q_DECLARE_METATYPE(Tp::MailList)
Q_DECLARE_METATYPE(Tp::MailURL)
Q_DECLARE_METATYPE(Tp::MediaDescriptionOffer)
Q_DECLARE_METATYPE(Tp::MediaDescriptionProperties)
Q_DECLARE_METATYPE(Tp::MediaSessionHandlerInfo)
Q_DECLARE_METATYPE(Tp::MediaSessionHandlerInfoList)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerCandidate)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerCandidateList)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerCodec)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerCodecList)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerTransport)
Q_DECLARE_METATYPE(Tp::MediaStreamHandlerTransportList)
Q_DECLARE_METATYPE(Tp::MediaStreamInfo)
Q_DECLARE_METATYPE(Tp::MediaStreamInfoList)
Q_DECLARE_METATYPE(Tp::MessagePart)
Q_DECLARE_METATYPE(Tp::MessagePartContentMap)
Q_DECLARE_METATYPE(Tp::MessagePartList)
Q_DECLARE_METATYPE(Tp::MessagePartListList)
Q_DECLARE_METATYPE(Tp::Metadata)
Q_DECLARE_METATYPE(Tp::MultipleStatusMap)
Q_DECLARE_METATYPE(Tp::NotDelegatedError)
Q_DECLARE_METATYPE(Tp::NotDelegatedMap)
Q_DECLARE_METATYPE(Tp::ObjectImmutablePropertiesMap)
Q_DECLARE_METATYPE(Tp::ObjectImmutablePropertiesMapList)
Q_DECLARE_METATYPE(Tp::ObjectPathList)
Q_DECLARE_METATYPE(Tp::ParamSpec)
Q_DECLARE_METATYPE(Tp::ParamSpecList)
Q_DECLARE_METATYPE(Tp::PendingTextMessage)
Q_DECLARE_METATYPE(Tp::PendingTextMessageList)
Q_DECLARE_METATYPE(Tp::PropertyFlagsChange)
Q_DECLARE_METATYPE(Tp::PropertyFlagsChangeList)
Q_DECLARE_METATYPE(Tp::PropertySpec)
Q_DECLARE_METATYPE(Tp::PropertySpecList)
Q_DECLARE_METATYPE(Tp::PropertyValue)
Q_DECLARE_METATYPE(Tp::PropertyValueList)
Q_DECLARE_METATYPE(Tp::ProtocolPropertiesMap)
Q_DECLARE_METATYPE(Tp::QualifiedPropertyValueMap)
Q_DECLARE_METATYPE(Tp::QualifiedPropertyValueMapList)
Q_DECLARE_METATYPE(Tp::RTCPFeedbackMessage)
Q_DECLARE_METATYPE(Tp::RTCPFeedbackMessageList)
Q_DECLARE_METATYPE(Tp::RTCPFeedbackMessageMap)
Q_DECLARE_METATYPE(Tp::RTCPFeedbackMessageProperties)
Q_DECLARE_METATYPE(Tp::RTPHeaderExtension)
Q_DECLARE_METATYPE(Tp::RTPHeaderExtensionsList)
Q_DECLARE_METATYPE(Tp::RequestableChannelClass)
Q_DECLARE_METATYPE(Tp::RequestableChannelClassList)
Q_DECLARE_METATYPE(Tp::RichPresenceAccessControl)
Q_DECLARE_METATYPE(Tp::RoomInfo)
Q_DECLARE_METATYPE(Tp::RoomInfoList)
Q_DECLARE_METATYPE(Tp::ServicePoint)
Q_DECLARE_METATYPE(Tp::ServicePointInfo)
Q_DECLARE_METATYPE(Tp::ServicePointInfoList)
Q_DECLARE_METATYPE(Tp::SimpleContactPresences)
Q_DECLARE_METATYPE(Tp::SimplePresence)
Q_DECLARE_METATYPE(Tp::SimpleStatusSpec)
Q_DECLARE_METATYPE(Tp::SimpleStatusSpecMap)
Q_DECLARE_METATYPE(Tp::SingleContactAttributesMap)
Q_DECLARE_METATYPE(Tp::SocketAddressIP)
Q_DECLARE_METATYPE(Tp::SocketAddressIPList)
Q_DECLARE_METATYPE(Tp::SocketAddressIPv4)
Q_DECLARE_METATYPE(Tp::SocketAddressIPv6)
Q_DECLARE_METATYPE(Tp::SocketNetmaskIPv4)
Q_DECLARE_METATYPE(Tp::SocketNetmaskIPv6)
Q_DECLARE_METATYPE(Tp::StatusSpec)
Q_DECLARE_METATYPE(Tp::StatusSpecMap)
Q_DECLARE_METATYPE(Tp::StreamCredentials)
Q_DECLARE_METATYPE(Tp::StringStringMap)
Q_DECLARE_METATYPE(Tp::StringStringMapList)
Q_DECLARE_METATYPE(Tp::StringVariantMap)
Q_DECLARE_METATYPE(Tp::StringVariantMapList)
Q_DECLARE_METATYPE(Tp::SupportedSocketMap)
Q_DECLARE_METATYPE(Tp::TLSCertificateRejection)
Q_DECLARE_METATYPE(Tp::TLSCertificateRejectionList)
Q_DECLARE_METATYPE(Tp::TubeInfo)
Q_DECLARE_METATYPE(Tp::TubeInfoList)
Q_DECLARE_METATYPE(Tp::UIntList)
Q_DECLARE_METATYPE(Tp::VCardFieldAddressMap)
Q_DECLARE_METATYPE(Tp::VideoResolution)
Q_DECLARE_METATYPE(Tp::VideoResolutionStruct)