// This file is generated by KDAB's kdwsdl2cpp from sdk.wsdl.
// All changes you do to this file will be lost.
/*
    You may use and relicense this generated file without restriction.
*/

#include "wsdl_iridium.h"

#include "KDSoapNamespaceManager.h"
#include <QSharedPointer>
#include "KDSoapMessage.h"
#include "KDSoapValue.h"
#include "KDSoapPendingCallWatcher.h"

class XS__Sdk_configuration_getSettings_response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_configuration_t > mConfigurations;
    bool mConfigurations_nil;
};

XS__Sdk_configuration_getSettings_response_t::PrivateDPtr::PrivateDPtr()
    : mError(0), mConfigurations_nil(true)
{
}


void XS__Sdk_configuration_getSettings_response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_configuration_getSettings_response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_configuration_getSettings_response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_configuration_getSettings_response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_configuration_getSettings_response_t::setConfigurations( const QList< XS__Sdk_configuration_t >& _configurations )
{
    d_ptr->mConfigurations_nil = false;
    d_ptr->mConfigurations = _configurations;
}

QList< XS__Sdk_configuration_t > XS__Sdk_configuration_getSettings_response_t::configurations() const
{
    return d_ptr->mConfigurations;
}

KDSoapValue XS__Sdk_configuration_getSettings_response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_getSettings_response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mConfigurations.count(); ++i) {
        KDSoapValue _valueConfigurations(d_ptr->mConfigurations.at(i).serialize(QString::fromLatin1("configurations")));
        _valueConfigurations.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueConfigurations);
    }
    return mainValue;
}

void XS__Sdk_configuration_getSettings_response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("configurations")) {
            XS__Sdk_configuration_t mConfigurationsTemp;
            mConfigurationsTemp.deserialize(val);
            d_ptr->mConfigurations.append(mConfigurationsTemp);
            d_ptr->mConfigurations_nil = false;
        }
    }
}

XS__Sdk_configuration_getSettings_response_t::XS__Sdk_configuration_getSettings_response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_getSettings_response_t::~XS__Sdk_configuration_getSettings_response_t()
{
}

XS__Sdk_configuration_getSettings_response_t::XS__Sdk_configuration_getSettings_response_t( const XS__Sdk_configuration_getSettings_response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_getSettings_response_t&  XS__Sdk_configuration_getSettings_response_t::operator=( const XS__Sdk_configuration_getSettings_response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_requestList_t::PrivateDPtr : public QSharedData
{
public:
    QList< XS__Sdk_configuration_tagRequest_t > mRequestList;
};

void XS__Sdk_configuration_requestList_t::setRequestList( const QList< XS__Sdk_configuration_tagRequest_t >& _requestList )
{
    d_ptr->mRequestList = _requestList;
}

QList< XS__Sdk_configuration_tagRequest_t > XS__Sdk_configuration_requestList_t::requestList() const
{
    return d_ptr->mRequestList;
}

KDSoapValue XS__Sdk_configuration_requestList_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_requestList_t"));
    KDSoapValueList& args = mainValue.childValues();
    for (int i = 0; i < d_ptr->mRequestList.count(); ++i) {
        KDSoapValue _valueRequestList(d_ptr->mRequestList.at(i).serialize(QString::fromLatin1("requestList")));
        _valueRequestList.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueRequestList);
    }
    return mainValue;
}

void XS__Sdk_configuration_requestList_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("requestList")) {
            XS__Sdk_configuration_tagRequest_t mRequestListTemp;
            mRequestListTemp.deserialize(val);
            d_ptr->mRequestList.append(mRequestListTemp);
        }
    }
}

XS__Sdk_configuration_requestList_t::XS__Sdk_configuration_requestList_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_requestList_t::~XS__Sdk_configuration_requestList_t()
{
}

XS__Sdk_configuration_requestList_t::XS__Sdk_configuration_requestList_t( const XS__Sdk_configuration_requestList_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_requestList_t&  XS__Sdk_configuration_requestList_t::operator=( const XS__Sdk_configuration_requestList_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_setRequst_list_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    QList< XS__Sdk_configuration_setRequst_t > mSetRequests;
    bool mSetRequests_nil;
};

XS__Sdk_configuration_setRequst_list_t::PrivateDPtr::PrivateDPtr()
    : mSetRequests_nil(true)
{
}


void XS__Sdk_configuration_setRequst_list_t::setSetRequests( const QList< XS__Sdk_configuration_setRequst_t >& _setRequests )
{
    d_ptr->mSetRequests_nil = false;
    d_ptr->mSetRequests = _setRequests;
}

QList< XS__Sdk_configuration_setRequst_t > XS__Sdk_configuration_setRequst_list_t::setRequests() const
{
    return d_ptr->mSetRequests;
}

KDSoapValue XS__Sdk_configuration_setRequst_list_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_setRequst_list_t"));
    KDSoapValueList& args = mainValue.childValues();
    for (int i = 0; i < d_ptr->mSetRequests.count(); ++i) {
        KDSoapValue _valueSetRequests(d_ptr->mSetRequests.at(i).serialize(QString::fromLatin1("setRequests")));
        _valueSetRequests.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueSetRequests);
    }
    return mainValue;
}

void XS__Sdk_configuration_setRequst_list_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("setRequests")) {
            XS__Sdk_configuration_setRequst_t mSetRequestsTemp;
            mSetRequestsTemp.deserialize(val);
            d_ptr->mSetRequests.append(mSetRequestsTemp);
            d_ptr->mSetRequests_nil = false;
        }
    }
}

XS__Sdk_configuration_setRequst_list_t::XS__Sdk_configuration_setRequst_list_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_setRequst_list_t::~XS__Sdk_configuration_setRequst_list_t()
{
}

XS__Sdk_configuration_setRequst_list_t::XS__Sdk_configuration_setRequst_list_t( const XS__Sdk_configuration_setRequst_list_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_setRequst_list_t&  XS__Sdk_configuration_setRequst_list_t::operator=( const XS__Sdk_configuration_setRequst_list_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_setRequst_t::PrivateDPtr : public QSharedData
{
public:
    QString mTag;
    QString mValue;
};

void XS__Sdk_configuration_setRequst_t::setTag( const QString& _tag )
{
    d_ptr->mTag = _tag;
}

QString XS__Sdk_configuration_setRequst_t::tag() const
{
    return d_ptr->mTag;
}

void XS__Sdk_configuration_setRequst_t::setValue( const QString& _value )
{
    d_ptr->mValue = _value;
}

QString XS__Sdk_configuration_setRequst_t::value() const
{
    return d_ptr->mValue;
}

KDSoapValue XS__Sdk_configuration_setRequst_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_setRequst_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTag(QString::fromLatin1("tag"), QVariant::fromValue(d_ptr->mTag), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueTag.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTag);
    KDSoapValue _valueValue(QString::fromLatin1("value"), QVariant::fromValue(d_ptr->mValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueValue);
    return mainValue;
}

void XS__Sdk_configuration_setRequst_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("tag")) {
            d_ptr->mTag = val.value().value<QString>();
        }
        else if (_name == QLatin1String("value")) {
            d_ptr->mValue = val.value().value<QString>();
        }
    }
}

XS__Sdk_configuration_setRequst_t::XS__Sdk_configuration_setRequst_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_setRequst_t::~XS__Sdk_configuration_setRequst_t()
{
}

XS__Sdk_configuration_setRequst_t::XS__Sdk_configuration_setRequst_t( const XS__Sdk_configuration_setRequst_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_setRequst_t&  XS__Sdk_configuration_setRequst_t::operator=( const XS__Sdk_configuration_setRequst_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_setSettings_response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_configuration_set_Result_t > mSetResults;
    bool mSetResults_nil;
};

XS__Sdk_configuration_setSettings_response_t::PrivateDPtr::PrivateDPtr()
    : mError(0), mSetResults_nil(true)
{
}


void XS__Sdk_configuration_setSettings_response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_configuration_setSettings_response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_configuration_setSettings_response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_configuration_setSettings_response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_configuration_setSettings_response_t::setSetResults( const QList< XS__Sdk_configuration_set_Result_t >& _setResults )
{
    d_ptr->mSetResults_nil = false;
    d_ptr->mSetResults = _setResults;
}

QList< XS__Sdk_configuration_set_Result_t > XS__Sdk_configuration_setSettings_response_t::setResults() const
{
    return d_ptr->mSetResults;
}

KDSoapValue XS__Sdk_configuration_setSettings_response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_setSettings_response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mSetResults.count(); ++i) {
        KDSoapValue _valueSetResults(d_ptr->mSetResults.at(i).serialize(QString::fromLatin1("setResults")));
        _valueSetResults.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueSetResults);
    }
    return mainValue;
}

void XS__Sdk_configuration_setSettings_response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("setResults")) {
            XS__Sdk_configuration_set_Result_t mSetResultsTemp;
            mSetResultsTemp.deserialize(val);
            d_ptr->mSetResults.append(mSetResultsTemp);
            d_ptr->mSetResults_nil = false;
        }
    }
}

XS__Sdk_configuration_setSettings_response_t::XS__Sdk_configuration_setSettings_response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_setSettings_response_t::~XS__Sdk_configuration_setSettings_response_t()
{
}

XS__Sdk_configuration_setSettings_response_t::XS__Sdk_configuration_setSettings_response_t( const XS__Sdk_configuration_setSettings_response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_setSettings_response_t&  XS__Sdk_configuration_setSettings_response_t::operator=( const XS__Sdk_configuration_setSettings_response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_set_Result_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    QString mTag;
    int mError;
    QString mMessage;
};

XS__Sdk_configuration_set_Result_t::PrivateDPtr::PrivateDPtr()
    : mError(0)
{
}


void XS__Sdk_configuration_set_Result_t::setTag( const QString& _tag )
{
    d_ptr->mTag = _tag;
}

QString XS__Sdk_configuration_set_Result_t::tag() const
{
    return d_ptr->mTag;
}

void XS__Sdk_configuration_set_Result_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_configuration_set_Result_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_configuration_set_Result_t::setMessage( const QString& _message )
{
    d_ptr->mMessage = _message;
}

QString XS__Sdk_configuration_set_Result_t::message() const
{
    return d_ptr->mMessage;
}

KDSoapValue XS__Sdk_configuration_set_Result_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_set_Result_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTag(QString::fromLatin1("tag"), QVariant::fromValue(d_ptr->mTag), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueTag.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTag);
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueMessage(QString::fromLatin1("message"), QVariant::fromValue(d_ptr->mMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueMessage);
    return mainValue;
}

void XS__Sdk_configuration_set_Result_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("tag")) {
            d_ptr->mTag = val.value().value<QString>();
        }
        else if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("message")) {
            d_ptr->mMessage = val.value().value<QString>();
        }
    }
}

XS__Sdk_configuration_set_Result_t::XS__Sdk_configuration_set_Result_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_set_Result_t::~XS__Sdk_configuration_set_Result_t()
{
}

XS__Sdk_configuration_set_Result_t::XS__Sdk_configuration_set_Result_t( const XS__Sdk_configuration_set_Result_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_set_Result_t&  XS__Sdk_configuration_set_Result_t::operator=( const XS__Sdk_configuration_set_Result_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_t::PrivateDPtr : public QSharedData
{
public:
    QString mTag;
    QString mFriendlyName;
    QString mDataType;
    QString mValue;
    QString mMinValue;
    QString mMaxValue;
};

void XS__Sdk_configuration_t::setTag( const QString& _tag )
{
    d_ptr->mTag = _tag;
}

QString XS__Sdk_configuration_t::tag() const
{
    return d_ptr->mTag;
}

void XS__Sdk_configuration_t::setFriendlyName( const QString& _friendlyName )
{
    d_ptr->mFriendlyName = _friendlyName;
}

QString XS__Sdk_configuration_t::friendlyName() const
{
    return d_ptr->mFriendlyName;
}

void XS__Sdk_configuration_t::setDataType( const QString& _dataType )
{
    d_ptr->mDataType = _dataType;
}

QString XS__Sdk_configuration_t::dataType() const
{
    return d_ptr->mDataType;
}

void XS__Sdk_configuration_t::setValue( const QString& _value )
{
    d_ptr->mValue = _value;
}

QString XS__Sdk_configuration_t::value() const
{
    return d_ptr->mValue;
}

void XS__Sdk_configuration_t::setMinValue( const QString& _minValue )
{
    d_ptr->mMinValue = _minValue;
}

QString XS__Sdk_configuration_t::minValue() const
{
    return d_ptr->mMinValue;
}

void XS__Sdk_configuration_t::setMaxValue( const QString& _maxValue )
{
    d_ptr->mMaxValue = _maxValue;
}

QString XS__Sdk_configuration_t::maxValue() const
{
    return d_ptr->mMaxValue;
}

KDSoapValue XS__Sdk_configuration_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTag(QString::fromLatin1("tag"), QVariant::fromValue(d_ptr->mTag), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueTag.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTag);
    KDSoapValue _valueFriendlyName(QString::fromLatin1("friendlyName"), QVariant::fromValue(d_ptr->mFriendlyName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueFriendlyName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueFriendlyName);
    KDSoapValue _valueDataType(QString::fromLatin1("dataType"), QVariant::fromValue(d_ptr->mDataType), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueDataType.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueDataType);
    KDSoapValue _valueValue(QString::fromLatin1("value"), QVariant::fromValue(d_ptr->mValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueValue);
    KDSoapValue _valueMinValue(QString::fromLatin1("minValue"), QVariant::fromValue(d_ptr->mMinValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueMinValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueMinValue);
    KDSoapValue _valueMaxValue(QString::fromLatin1("maxValue"), QVariant::fromValue(d_ptr->mMaxValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueMaxValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueMaxValue);
    return mainValue;
}

void XS__Sdk_configuration_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("tag")) {
            d_ptr->mTag = val.value().value<QString>();
        }
        else if (_name == QLatin1String("friendlyName")) {
            d_ptr->mFriendlyName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("dataType")) {
            d_ptr->mDataType = val.value().value<QString>();
        }
        else if (_name == QLatin1String("value")) {
            d_ptr->mValue = val.value().value<QString>();
        }
        else if (_name == QLatin1String("minValue")) {
            d_ptr->mMinValue = val.value().value<QString>();
        }
        else if (_name == QLatin1String("maxValue")) {
            d_ptr->mMaxValue = val.value().value<QString>();
        }
    }
}

XS__Sdk_configuration_t::XS__Sdk_configuration_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_t::~XS__Sdk_configuration_t()
{
}

XS__Sdk_configuration_t::XS__Sdk_configuration_t( const XS__Sdk_configuration_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_t&  XS__Sdk_configuration_t::operator=( const XS__Sdk_configuration_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_configuration_tagRequest_t::PrivateDPtr : public QSharedData
{
public:
    QString mTag;
};

void XS__Sdk_configuration_tagRequest_t::setTag( const QString& _tag )
{
    d_ptr->mTag = _tag;
}

QString XS__Sdk_configuration_tagRequest_t::tag() const
{
    return d_ptr->mTag;
}

KDSoapValue XS__Sdk_configuration_tagRequest_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_configuration_tagRequest_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTag(QString::fromLatin1("tag"), QVariant::fromValue(d_ptr->mTag), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueTag.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTag);
    return mainValue;
}

void XS__Sdk_configuration_tagRequest_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("tag")) {
            d_ptr->mTag = val.value().value<QString>();
        }
    }
}

XS__Sdk_configuration_tagRequest_t::XS__Sdk_configuration_tagRequest_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_configuration_tagRequest_t::~XS__Sdk_configuration_tagRequest_t()
{
}

XS__Sdk_configuration_tagRequest_t::XS__Sdk_configuration_tagRequest_t( const XS__Sdk_configuration_tagRequest_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_configuration_tagRequest_t&  XS__Sdk_configuration_tagRequest_t::operator=( const XS__Sdk_configuration_tagRequest_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_contact_add_modify_remove_Response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
};

XS__Sdk_contact_add_modify_remove_Response_t::PrivateDPtr::PrivateDPtr()
    : mError(0)
{
}


void XS__Sdk_contact_add_modify_remove_Response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_contact_add_modify_remove_Response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_contact_add_modify_remove_Response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_contact_add_modify_remove_Response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

KDSoapValue XS__Sdk_contact_add_modify_remove_Response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_contact_add_modify_remove_Response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    return mainValue;
}

void XS__Sdk_contact_add_modify_remove_Response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
    }
}

XS__Sdk_contact_add_modify_remove_Response_t::XS__Sdk_contact_add_modify_remove_Response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_contact_add_modify_remove_Response_t::~XS__Sdk_contact_add_modify_remove_Response_t()
{
}

XS__Sdk_contact_add_modify_remove_Response_t::XS__Sdk_contact_add_modify_remove_Response_t( const XS__Sdk_contact_add_modify_remove_Response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_contact_add_modify_remove_Response_t&  XS__Sdk_contact_add_modify_remove_Response_t::operator=( const XS__Sdk_contact_add_modify_remove_Response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_contact_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mId;
    QString mName;
    QString mNumber;
    bool mIsFavourite;
};

XS__Sdk_contact_t::PrivateDPtr::PrivateDPtr()
    : mId(0), mIsFavourite(false)
{
}


void XS__Sdk_contact_t::setId( int _id )
{
    d_ptr->mId = _id;
}

int XS__Sdk_contact_t::id() const
{
    return d_ptr->mId;
}

void XS__Sdk_contact_t::setName( const QString& _name )
{
    d_ptr->mName = _name;
}

QString XS__Sdk_contact_t::name() const
{
    return d_ptr->mName;
}

void XS__Sdk_contact_t::setNumber( const QString& _number )
{
    d_ptr->mNumber = _number;
}

QString XS__Sdk_contact_t::number() const
{
    return d_ptr->mNumber;
}

void XS__Sdk_contact_t::setIsFavourite( bool _isFavourite )
{
    d_ptr->mIsFavourite = _isFavourite;
}

bool XS__Sdk_contact_t::isFavourite() const
{
    return d_ptr->mIsFavourite;
}

KDSoapValue XS__Sdk_contact_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_contact_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueId(QString::fromLatin1("id"), QVariant::fromValue(d_ptr->mId), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueId.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueId);
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(d_ptr->mName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueName);
    KDSoapValue _valueNumber(QString::fromLatin1("number"), QVariant::fromValue(d_ptr->mNumber), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueNumber.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueNumber);
    KDSoapValue _valueIsFavourite(QString::fromLatin1("isFavourite"), QVariant::fromValue(d_ptr->mIsFavourite), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueIsFavourite.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueIsFavourite);
    return mainValue;
}

void XS__Sdk_contact_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("id")) {
            d_ptr->mId = val.value().value<int>();
        }
        else if (_name == QLatin1String("name")) {
            d_ptr->mName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("number")) {
            d_ptr->mNumber = val.value().value<QString>();
        }
        else if (_name == QLatin1String("isFavourite")) {
            d_ptr->mIsFavourite = val.value().value<bool>();
        }
    }
}

XS__Sdk_contact_t::XS__Sdk_contact_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_contact_t::~XS__Sdk_contact_t()
{
}

XS__Sdk_contact_t::XS__Sdk_contact_t( const XS__Sdk_contact_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_contact_t&  XS__Sdk_contact_t::operator=( const XS__Sdk_contact_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_contacts_getList_Response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_contact_t > mContacts;
    bool mContacts_nil;
};

XS__Sdk_contacts_getList_Response_t::PrivateDPtr::PrivateDPtr()
    : mError(0), mContacts_nil(true)
{
}


void XS__Sdk_contacts_getList_Response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_contacts_getList_Response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_contacts_getList_Response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_contacts_getList_Response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_contacts_getList_Response_t::setContacts( const QList< XS__Sdk_contact_t >& _contacts )
{
    d_ptr->mContacts_nil = false;
    d_ptr->mContacts = _contacts;
}

QList< XS__Sdk_contact_t > XS__Sdk_contacts_getList_Response_t::contacts() const
{
    return d_ptr->mContacts;
}

KDSoapValue XS__Sdk_contacts_getList_Response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_contacts_getList_Response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mContacts.count(); ++i) {
        KDSoapValue _valueContacts(d_ptr->mContacts.at(i).serialize(QString::fromLatin1("contacts")));
        _valueContacts.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueContacts);
    }
    return mainValue;
}

void XS__Sdk_contacts_getList_Response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("contacts")) {
            XS__Sdk_contact_t mContactsTemp;
            mContactsTemp.deserialize(val);
            d_ptr->mContacts.append(mContactsTemp);
            d_ptr->mContacts_nil = false;
        }
    }
}

XS__Sdk_contacts_getList_Response_t::XS__Sdk_contacts_getList_Response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_contacts_getList_Response_t::~XS__Sdk_contacts_getList_Response_t()
{
}

XS__Sdk_contacts_getList_Response_t::XS__Sdk_contacts_getList_Response_t( const XS__Sdk_contacts_getList_Response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_contacts_getList_Response_t&  XS__Sdk_contacts_getList_Response_t::operator=( const XS__Sdk_contacts_getList_Response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_generic_option_t::PrivateDPtr : public QSharedData
{
public:
    QString mName;
    QString mValue;
    QString mDataType;
};

void XS__Sdk_generic_option_t::setName( const QString& _name )
{
    d_ptr->mName = _name;
}

QString XS__Sdk_generic_option_t::name() const
{
    return d_ptr->mName;
}

void XS__Sdk_generic_option_t::setValue( const QString& _value )
{
    d_ptr->mValue = _value;
}

QString XS__Sdk_generic_option_t::value() const
{
    return d_ptr->mValue;
}

void XS__Sdk_generic_option_t::setDataType( const QString& _dataType )
{
    d_ptr->mDataType = _dataType;
}

QString XS__Sdk_generic_option_t::dataType() const
{
    return d_ptr->mDataType;
}

KDSoapValue XS__Sdk_generic_option_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_generic_option_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(d_ptr->mName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueName);
    KDSoapValue _valueValue(QString::fromLatin1("value"), QVariant::fromValue(d_ptr->mValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueValue);
    KDSoapValue _valueDataType(QString::fromLatin1("dataType"), QVariant::fromValue(d_ptr->mDataType), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueDataType.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueDataType);
    return mainValue;
}

void XS__Sdk_generic_option_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("name")) {
            d_ptr->mName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("value")) {
            d_ptr->mValue = val.value().value<QString>();
        }
        else if (_name == QLatin1String("dataType")) {
            d_ptr->mDataType = val.value().value<QString>();
        }
    }
}

XS__Sdk_generic_option_t::XS__Sdk_generic_option_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_generic_option_t::~XS__Sdk_generic_option_t()
{
}

XS__Sdk_generic_option_t::XS__Sdk_generic_option_t( const XS__Sdk_generic_option_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_generic_option_t&  XS__Sdk_generic_option_t::operator=( const XS__Sdk_generic_option_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_status_get_response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_status_t > mStatus;
};

XS__Sdk_status_get_response_t::PrivateDPtr::PrivateDPtr()
    : mError(0)
{
}


void XS__Sdk_status_get_response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_status_get_response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_status_get_response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_status_get_response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_status_get_response_t::setStatus( const QList< XS__Sdk_status_t >& _status )
{
    d_ptr->mStatus = _status;
}

QList< XS__Sdk_status_t > XS__Sdk_status_get_response_t::status() const
{
    return d_ptr->mStatus;
}

KDSoapValue XS__Sdk_status_get_response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_status_get_response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mStatus.count(); ++i) {
        KDSoapValue _valueStatus(d_ptr->mStatus.at(i).serialize(QString::fromLatin1("status")));
        _valueStatus.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueStatus);
    }
    return mainValue;
}

void XS__Sdk_status_get_response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("status")) {
            XS__Sdk_status_t mStatusTemp;
            mStatusTemp.deserialize(val);
            d_ptr->mStatus.append(mStatusTemp);
        }
    }
}

XS__Sdk_status_get_response_t::XS__Sdk_status_get_response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_status_get_response_t::~XS__Sdk_status_get_response_t()
{
}

XS__Sdk_status_get_response_t::XS__Sdk_status_get_response_t( const XS__Sdk_status_get_response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_status_get_response_t&  XS__Sdk_status_get_response_t::operator=( const XS__Sdk_status_get_response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_status_request_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    QList< XS__Sdk_generic_option_t > mOptions;
    bool mOptions_nil;
};

XS__Sdk_status_request_t::PrivateDPtr::PrivateDPtr()
    : mOptions_nil(true)
{
}


void XS__Sdk_status_request_t::setOptions( const QList< XS__Sdk_generic_option_t >& _options )
{
    d_ptr->mOptions_nil = false;
    d_ptr->mOptions = _options;
}

QList< XS__Sdk_generic_option_t > XS__Sdk_status_request_t::options() const
{
    return d_ptr->mOptions;
}

KDSoapValue XS__Sdk_status_request_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_status_request_t"));
    KDSoapValueList& args = mainValue.childValues();
    for (int i = 0; i < d_ptr->mOptions.count(); ++i) {
        KDSoapValue _valueOptions(d_ptr->mOptions.at(i).serialize(QString::fromLatin1("options")));
        _valueOptions.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueOptions);
    }
    return mainValue;
}

void XS__Sdk_status_request_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("options")) {
            XS__Sdk_generic_option_t mOptionsTemp;
            mOptionsTemp.deserialize(val);
            d_ptr->mOptions.append(mOptionsTemp);
            d_ptr->mOptions_nil = false;
        }
    }
}

XS__Sdk_status_request_t::XS__Sdk_status_request_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_status_request_t::~XS__Sdk_status_request_t()
{
}

XS__Sdk_status_request_t::XS__Sdk_status_request_t( const XS__Sdk_status_request_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_status_request_t&  XS__Sdk_status_request_t::operator=( const XS__Sdk_status_request_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_status_t::PrivateDPtr : public QSharedData
{
public:
    QString mName;
    QString mValue;
};

void XS__Sdk_status_t::setName( const QString& _name )
{
    d_ptr->mName = _name;
}

QString XS__Sdk_status_t::name() const
{
    return d_ptr->mName;
}

void XS__Sdk_status_t::setValue( const QString& _value )
{
    d_ptr->mValue = _value;
}

QString XS__Sdk_status_t::value() const
{
    return d_ptr->mValue;
}

KDSoapValue XS__Sdk_status_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_status_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(d_ptr->mName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueName);
    KDSoapValue _valueValue(QString::fromLatin1("value"), QVariant::fromValue(d_ptr->mValue), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueValue.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueValue);
    return mainValue;
}

void XS__Sdk_status_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("name")) {
            d_ptr->mName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("value")) {
            d_ptr->mValue = val.value().value<QString>();
        }
    }
}

XS__Sdk_status_t::XS__Sdk_status_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_status_t::~XS__Sdk_status_t()
{
}

XS__Sdk_status_t::XS__Sdk_status_t( const XS__Sdk_status_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_status_t&  XS__Sdk_status_t::operator=( const XS__Sdk_status_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_task_perform_Result_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mTaskID;
    int mResponseCode;
    QString mMessage;
};

XS__Sdk_task_perform_Result_t::PrivateDPtr::PrivateDPtr()
    : mTaskID(0), mResponseCode(0)
{
}


void XS__Sdk_task_perform_Result_t::setTaskID( int _taskID )
{
    d_ptr->mTaskID = _taskID;
}

int XS__Sdk_task_perform_Result_t::taskID() const
{
    return d_ptr->mTaskID;
}

void XS__Sdk_task_perform_Result_t::setResponseCode( int _responseCode )
{
    d_ptr->mResponseCode = _responseCode;
}

int XS__Sdk_task_perform_Result_t::responseCode() const
{
    return d_ptr->mResponseCode;
}

void XS__Sdk_task_perform_Result_t::setMessage( const QString& _message )
{
    d_ptr->mMessage = _message;
}

QString XS__Sdk_task_perform_Result_t::message() const
{
    return d_ptr->mMessage;
}

KDSoapValue XS__Sdk_task_perform_Result_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_task_perform_Result_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTaskID(QString::fromLatin1("taskID"), QVariant::fromValue(d_ptr->mTaskID), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueTaskID.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTaskID);
    KDSoapValue _valueResponseCode(QString::fromLatin1("responseCode"), QVariant::fromValue(d_ptr->mResponseCode), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueResponseCode.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueResponseCode);
    KDSoapValue _valueMessage(QString::fromLatin1("message"), QVariant::fromValue(d_ptr->mMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueMessage);
    return mainValue;
}

void XS__Sdk_task_perform_Result_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("taskID")) {
            d_ptr->mTaskID = val.value().value<int>();
        }
        else if (_name == QLatin1String("responseCode")) {
            d_ptr->mResponseCode = val.value().value<int>();
        }
        else if (_name == QLatin1String("message")) {
            d_ptr->mMessage = val.value().value<QString>();
        }
    }
}

XS__Sdk_task_perform_Result_t::XS__Sdk_task_perform_Result_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_task_perform_Result_t::~XS__Sdk_task_perform_Result_t()
{
}

XS__Sdk_task_perform_Result_t::XS__Sdk_task_perform_Result_t( const XS__Sdk_task_perform_Result_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_task_perform_Result_t&  XS__Sdk_task_perform_Result_t::operator=( const XS__Sdk_task_perform_Result_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_task_perform_response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_task_perform_Result_t > mTaskResults;
    bool mTaskResults_nil;
};

XS__Sdk_task_perform_response_t::PrivateDPtr::PrivateDPtr()
    : mError(0), mTaskResults_nil(true)
{
}


void XS__Sdk_task_perform_response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_task_perform_response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_task_perform_response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_task_perform_response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_task_perform_response_t::setTaskResults( const QList< XS__Sdk_task_perform_Result_t >& _taskResults )
{
    d_ptr->mTaskResults_nil = false;
    d_ptr->mTaskResults = _taskResults;
}

QList< XS__Sdk_task_perform_Result_t > XS__Sdk_task_perform_response_t::taskResults() const
{
    return d_ptr->mTaskResults;
}

KDSoapValue XS__Sdk_task_perform_response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_task_perform_response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mTaskResults.count(); ++i) {
        KDSoapValue _valueTaskResults(d_ptr->mTaskResults.at(i).serialize(QString::fromLatin1("taskResults")));
        _valueTaskResults.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueTaskResults);
    }
    return mainValue;
}

void XS__Sdk_task_perform_response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("taskResults")) {
            XS__Sdk_task_perform_Result_t mTaskResultsTemp;
            mTaskResultsTemp.deserialize(val);
            d_ptr->mTaskResults.append(mTaskResultsTemp);
            d_ptr->mTaskResults_nil = false;
        }
    }
}

XS__Sdk_task_perform_response_t::XS__Sdk_task_perform_response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_task_perform_response_t::~XS__Sdk_task_perform_response_t()
{
}

XS__Sdk_task_perform_response_t::XS__Sdk_task_perform_response_t( const XS__Sdk_task_perform_response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_task_perform_response_t&  XS__Sdk_task_perform_response_t::operator=( const XS__Sdk_task_perform_response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_task_requestList_t::PrivateDPtr : public QSharedData
{
public:
    QList< XS__Sdk_task_request_t > mRequestList;
};

void XS__Sdk_task_requestList_t::setRequestList( const QList< XS__Sdk_task_request_t >& _requestList )
{
    d_ptr->mRequestList = _requestList;
}

QList< XS__Sdk_task_request_t > XS__Sdk_task_requestList_t::requestList() const
{
    return d_ptr->mRequestList;
}

KDSoapValue XS__Sdk_task_requestList_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_task_requestList_t"));
    KDSoapValueList& args = mainValue.childValues();
    for (int i = 0; i < d_ptr->mRequestList.count(); ++i) {
        KDSoapValue _valueRequestList(d_ptr->mRequestList.at(i).serialize(QString::fromLatin1("requestList")));
        _valueRequestList.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueRequestList);
    }
    return mainValue;
}

void XS__Sdk_task_requestList_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("requestList")) {
            XS__Sdk_task_request_t mRequestListTemp;
            mRequestListTemp.deserialize(val);
            d_ptr->mRequestList.append(mRequestListTemp);
        }
    }
}

XS__Sdk_task_requestList_t::XS__Sdk_task_requestList_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_task_requestList_t::~XS__Sdk_task_requestList_t()
{
}

XS__Sdk_task_requestList_t::XS__Sdk_task_requestList_t( const XS__Sdk_task_requestList_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_task_requestList_t&  XS__Sdk_task_requestList_t::operator=( const XS__Sdk_task_requestList_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_task_request_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mTaskID;
    QList< XS__Sdk_generic_option_t > mOptions;
    bool mOptions_nil;
};

XS__Sdk_task_request_t::PrivateDPtr::PrivateDPtr()
    : mTaskID(0), mOptions_nil(true)
{
}


void XS__Sdk_task_request_t::setTaskID( int _taskID )
{
    d_ptr->mTaskID = _taskID;
}

int XS__Sdk_task_request_t::taskID() const
{
    return d_ptr->mTaskID;
}

void XS__Sdk_task_request_t::setOptions( const QList< XS__Sdk_generic_option_t >& _options )
{
    d_ptr->mOptions_nil = false;
    d_ptr->mOptions = _options;
}

QList< XS__Sdk_generic_option_t > XS__Sdk_task_request_t::options() const
{
    return d_ptr->mOptions;
}

KDSoapValue XS__Sdk_task_request_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_task_request_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueTaskID(QString::fromLatin1("taskID"), QVariant::fromValue(d_ptr->mTaskID), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueTaskID.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTaskID);
    for (int i = 0; i < d_ptr->mOptions.count(); ++i) {
        KDSoapValue _valueOptions(d_ptr->mOptions.at(i).serialize(QString::fromLatin1("options")));
        _valueOptions.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueOptions);
    }
    return mainValue;
}

void XS__Sdk_task_request_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("taskID")) {
            d_ptr->mTaskID = val.value().value<int>();
        }
        else if (_name == QLatin1String("options")) {
            XS__Sdk_generic_option_t mOptionsTemp;
            mOptionsTemp.deserialize(val);
            d_ptr->mOptions.append(mOptionsTemp);
            d_ptr->mOptions_nil = false;
        }
    }
}

XS__Sdk_task_request_t::XS__Sdk_task_request_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_task_request_t::~XS__Sdk_task_request_t()
{
}

XS__Sdk_task_request_t::XS__Sdk_task_request_t( const XS__Sdk_task_request_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_task_request_t&  XS__Sdk_task_request_t::operator=( const XS__Sdk_task_request_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_user_add_modify_remove_Response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
};

XS__Sdk_user_add_modify_remove_Response_t::PrivateDPtr::PrivateDPtr()
    : mError(0)
{
}


void XS__Sdk_user_add_modify_remove_Response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_user_add_modify_remove_Response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_user_add_modify_remove_Response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_user_add_modify_remove_Response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

KDSoapValue XS__Sdk_user_add_modify_remove_Response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_user_add_modify_remove_Response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    return mainValue;
}

void XS__Sdk_user_add_modify_remove_Response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
    }
}

XS__Sdk_user_add_modify_remove_Response_t::XS__Sdk_user_add_modify_remove_Response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_user_add_modify_remove_Response_t::~XS__Sdk_user_add_modify_remove_Response_t()
{
}

XS__Sdk_user_add_modify_remove_Response_t::XS__Sdk_user_add_modify_remove_Response_t( const XS__Sdk_user_add_modify_remove_Response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_user_add_modify_remove_Response_t&  XS__Sdk_user_add_modify_remove_Response_t::operator=( const XS__Sdk_user_add_modify_remove_Response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_user_credentials_t::PrivateDPtr : public QSharedData
{
public:
    QString mUserName;
    QString mPassword;
};

void XS__Sdk_user_credentials_t::setUserName( const QString& _userName )
{
    d_ptr->mUserName = _userName;
}

QString XS__Sdk_user_credentials_t::userName() const
{
    return d_ptr->mUserName;
}

void XS__Sdk_user_credentials_t::setPassword( const QString& _password )
{
    d_ptr->mPassword = _password;
}

QString XS__Sdk_user_credentials_t::password() const
{
    return d_ptr->mPassword;
}

KDSoapValue XS__Sdk_user_credentials_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_user_credentials_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueUserName(QString::fromLatin1("userName"), QVariant::fromValue(d_ptr->mUserName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueUserName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueUserName);
    KDSoapValue _valuePassword(QString::fromLatin1("password"), QVariant::fromValue(d_ptr->mPassword), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valuePassword.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valuePassword);
    return mainValue;
}

void XS__Sdk_user_credentials_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("userName")) {
            d_ptr->mUserName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("password")) {
            d_ptr->mPassword = val.value().value<QString>();
        }
    }
}

XS__Sdk_user_credentials_t::XS__Sdk_user_credentials_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_user_credentials_t::~XS__Sdk_user_credentials_t()
{
}

XS__Sdk_user_credentials_t::XS__Sdk_user_credentials_t( const XS__Sdk_user_credentials_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_user_credentials_t&  XS__Sdk_user_credentials_t::operator=( const XS__Sdk_user_credentials_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_user_details_response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    XS__Sdk_user_t mUser;
};

XS__Sdk_user_details_response_t::PrivateDPtr::PrivateDPtr()
    : mError(0)
{
}


void XS__Sdk_user_details_response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_user_details_response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_user_details_response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_user_details_response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_user_details_response_t::setUser( const XS__Sdk_user_t& _user )
{
    d_ptr->mUser = _user;
}

XS__Sdk_user_t XS__Sdk_user_details_response_t::user() const
{
    return d_ptr->mUser;
}

KDSoapValue XS__Sdk_user_details_response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_user_details_response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    KDSoapValue _valueUser(d_ptr->mUser.serialize(QString::fromLatin1("user")));
    _valueUser.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueUser);
    return mainValue;
}

void XS__Sdk_user_details_response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("user")) {
            d_ptr->mUser.deserialize(val);
        }
    }
}

XS__Sdk_user_details_response_t::XS__Sdk_user_details_response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_user_details_response_t::~XS__Sdk_user_details_response_t()
{
}

XS__Sdk_user_details_response_t::XS__Sdk_user_details_response_t( const XS__Sdk_user_details_response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_user_details_response_t&  XS__Sdk_user_details_response_t::operator=( const XS__Sdk_user_details_response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_user_getList_Response_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    int mError;
    QString mErrorMessage;
    QList< XS__Sdk_user_t > mUsers;
    bool mUsers_nil;
};

XS__Sdk_user_getList_Response_t::PrivateDPtr::PrivateDPtr()
    : mError(0), mUsers_nil(true)
{
}


void XS__Sdk_user_getList_Response_t::setError( int _error )
{
    d_ptr->mError = _error;
}

int XS__Sdk_user_getList_Response_t::error() const
{
    return d_ptr->mError;
}

void XS__Sdk_user_getList_Response_t::setErrorMessage( const QString& _errorMessage )
{
    d_ptr->mErrorMessage = _errorMessage;
}

QString XS__Sdk_user_getList_Response_t::errorMessage() const
{
    return d_ptr->mErrorMessage;
}

void XS__Sdk_user_getList_Response_t::setUsers( const QList< XS__Sdk_user_t >& _users )
{
    d_ptr->mUsers_nil = false;
    d_ptr->mUsers = _users;
}

QList< XS__Sdk_user_t > XS__Sdk_user_getList_Response_t::users() const
{
    return d_ptr->mUsers;
}

KDSoapValue XS__Sdk_user_getList_Response_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_user_getList_Response_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueError(QString::fromLatin1("error"), QVariant::fromValue(d_ptr->mError), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueError.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueError);
    KDSoapValue _valueErrorMessage(QString::fromLatin1("errorMessage"), QVariant::fromValue(d_ptr->mErrorMessage), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueErrorMessage.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueErrorMessage);
    for (int i = 0; i < d_ptr->mUsers.count(); ++i) {
        KDSoapValue _valueUsers(d_ptr->mUsers.at(i).serialize(QString::fromLatin1("users")));
        _valueUsers.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
        args.append(_valueUsers);
    }
    return mainValue;
}

void XS__Sdk_user_getList_Response_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("error")) {
            d_ptr->mError = val.value().value<int>();
        }
        else if (_name == QLatin1String("errorMessage")) {
            d_ptr->mErrorMessage = val.value().value<QString>();
        }
        else if (_name == QLatin1String("users")) {
            XS__Sdk_user_t mUsersTemp;
            mUsersTemp.deserialize(val);
            d_ptr->mUsers.append(mUsersTemp);
            d_ptr->mUsers_nil = false;
        }
    }
}

XS__Sdk_user_getList_Response_t::XS__Sdk_user_getList_Response_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_user_getList_Response_t::~XS__Sdk_user_getList_Response_t()
{
}

XS__Sdk_user_getList_Response_t::XS__Sdk_user_getList_Response_t( const XS__Sdk_user_getList_Response_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_user_getList_Response_t&  XS__Sdk_user_getList_Response_t::operator=( const XS__Sdk_user_getList_Response_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_user_t::PrivateDPtr : public QSharedData
{
public:
    PrivateDPtr();

public:
    QString mUserName;
    QString mPassword;
    bool mOutgoingCall;
    int mUserPriority;
    bool mSendSms;
    bool mReceiveSms;
    bool mCanAccessTwitter;
    bool mTracking;
    bool mIsAdmin;
};

XS__Sdk_user_t::PrivateDPtr::PrivateDPtr()
    : mOutgoingCall(false), mUserPriority(0), mSendSms(false), mReceiveSms(false), mCanAccessTwitter(false), mTracking(false), mIsAdmin(false)
{
}


void XS__Sdk_user_t::setUserName( const QString& _userName )
{
    d_ptr->mUserName = _userName;
}

QString XS__Sdk_user_t::userName() const
{
    return d_ptr->mUserName;
}

void XS__Sdk_user_t::setPassword( const QString& _password )
{
    d_ptr->mPassword = _password;
}

QString XS__Sdk_user_t::password() const
{
    return d_ptr->mPassword;
}

void XS__Sdk_user_t::setOutgoingCall( bool _outgoingCall )
{
    d_ptr->mOutgoingCall = _outgoingCall;
}

bool XS__Sdk_user_t::outgoingCall() const
{
    return d_ptr->mOutgoingCall;
}

void XS__Sdk_user_t::setUserPriority( int _userPriority )
{
    d_ptr->mUserPriority = _userPriority;
}

int XS__Sdk_user_t::userPriority() const
{
    return d_ptr->mUserPriority;
}

void XS__Sdk_user_t::setSendSms( bool _sendSms )
{
    d_ptr->mSendSms = _sendSms;
}

bool XS__Sdk_user_t::sendSms() const
{
    return d_ptr->mSendSms;
}

void XS__Sdk_user_t::setReceiveSms( bool _receiveSms )
{
    d_ptr->mReceiveSms = _receiveSms;
}

bool XS__Sdk_user_t::receiveSms() const
{
    return d_ptr->mReceiveSms;
}

void XS__Sdk_user_t::setCanAccessTwitter( bool _canAccessTwitter )
{
    d_ptr->mCanAccessTwitter = _canAccessTwitter;
}

bool XS__Sdk_user_t::canAccessTwitter() const
{
    return d_ptr->mCanAccessTwitter;
}

void XS__Sdk_user_t::setTracking( bool _tracking )
{
    d_ptr->mTracking = _tracking;
}

bool XS__Sdk_user_t::tracking() const
{
    return d_ptr->mTracking;
}

void XS__Sdk_user_t::setIsAdmin( bool _isAdmin )
{
    d_ptr->mIsAdmin = _isAdmin;
}

bool XS__Sdk_user_t::isAdmin() const
{
    return d_ptr->mIsAdmin;
}

KDSoapValue XS__Sdk_user_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_user_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueUserName(QString::fromLatin1("userName"), QVariant::fromValue(d_ptr->mUserName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueUserName.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueUserName);
    KDSoapValue _valuePassword(QString::fromLatin1("password"), QVariant::fromValue(d_ptr->mPassword), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valuePassword.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valuePassword);
    KDSoapValue _valueOutgoingCall(QString::fromLatin1("outgoingCall"), QVariant::fromValue(d_ptr->mOutgoingCall), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueOutgoingCall.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueOutgoingCall);
    KDSoapValue _valueUserPriority(QString::fromLatin1("userPriority"), QVariant::fromValue(d_ptr->mUserPriority), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueUserPriority.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueUserPriority);
    KDSoapValue _valueSendSms(QString::fromLatin1("sendSms"), QVariant::fromValue(d_ptr->mSendSms), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueSendSms.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueSendSms);
    KDSoapValue _valueReceiveSms(QString::fromLatin1("receiveSms"), QVariant::fromValue(d_ptr->mReceiveSms), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueReceiveSms.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueReceiveSms);
    KDSoapValue _valueCanAccessTwitter(QString::fromLatin1("canAccessTwitter"), QVariant::fromValue(d_ptr->mCanAccessTwitter), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueCanAccessTwitter.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueCanAccessTwitter);
    KDSoapValue _valueTracking(QString::fromLatin1("tracking"), QVariant::fromValue(d_ptr->mTracking), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueTracking.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueTracking);
    KDSoapValue _valueIsAdmin(QString::fromLatin1("isAdmin"), QVariant::fromValue(d_ptr->mIsAdmin), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueIsAdmin.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueIsAdmin);
    return mainValue;
}

void XS__Sdk_user_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("userName")) {
            d_ptr->mUserName = val.value().value<QString>();
        }
        else if (_name == QLatin1String("password")) {
            d_ptr->mPassword = val.value().value<QString>();
        }
        else if (_name == QLatin1String("outgoingCall")) {
            d_ptr->mOutgoingCall = val.value().value<bool>();
        }
        else if (_name == QLatin1String("userPriority")) {
            d_ptr->mUserPriority = val.value().value<int>();
        }
        else if (_name == QLatin1String("sendSms")) {
            d_ptr->mSendSms = val.value().value<bool>();
        }
        else if (_name == QLatin1String("receiveSms")) {
            d_ptr->mReceiveSms = val.value().value<bool>();
        }
        else if (_name == QLatin1String("canAccessTwitter")) {
            d_ptr->mCanAccessTwitter = val.value().value<bool>();
        }
        else if (_name == QLatin1String("tracking")) {
            d_ptr->mTracking = val.value().value<bool>();
        }
        else if (_name == QLatin1String("isAdmin")) {
            d_ptr->mIsAdmin = val.value().value<bool>();
        }
    }
}

XS__Sdk_user_t::XS__Sdk_user_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_user_t::~XS__Sdk_user_t()
{
}

XS__Sdk_user_t::XS__Sdk_user_t( const XS__Sdk_user_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_user_t&  XS__Sdk_user_t::operator=( const XS__Sdk_user_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


class XS__Sdk_version_t::PrivateDPtr : public QSharedData
{
public:
    QString mApiVersion;
    QString mFirmwareVersion;
};

void XS__Sdk_version_t::setApiVersion( const QString& _apiVersion )
{
    d_ptr->mApiVersion = _apiVersion;
}

QString XS__Sdk_version_t::apiVersion() const
{
    return d_ptr->mApiVersion;
}

void XS__Sdk_version_t::setFirmwareVersion( const QString& _firmwareVersion )
{
    d_ptr->mFirmwareVersion = _firmwareVersion;
}

QString XS__Sdk_version_t::firmwareVersion() const
{
    return d_ptr->mFirmwareVersion;
}

KDSoapValue XS__Sdk_version_t::serialize( const QString& valueName ) const
{
    KDSoapValue mainValue(valueName, QVariant(), QString::fromLatin1("http://iridiumgo.lan/sdk/"), QString::fromLatin1("sdk_version_t"));
    KDSoapValueList& args = mainValue.childValues();
    KDSoapValue _valueApiVersion(QString::fromLatin1("apiVersion"), QVariant::fromValue(d_ptr->mApiVersion), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueApiVersion.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueApiVersion);
    KDSoapValue _valueFirmwareVersion(QString::fromLatin1("firmwareVersion"), QVariant::fromValue(d_ptr->mFirmwareVersion), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueFirmwareVersion.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    args.append(_valueFirmwareVersion);
    return mainValue;
}

void XS__Sdk_version_t::deserialize( const KDSoapValue& mainValue )
{
    const KDSoapValueList& args = mainValue.childValues();
    for (int argNr = 0; argNr < args.count(); ++argNr) {
        const KDSoapValue& val = args.at(argNr);
        const QString _name = val.name();
        if (_name == QLatin1String("apiVersion")) {
            d_ptr->mApiVersion = val.value().value<QString>();
        }
        else if (_name == QLatin1String("firmwareVersion")) {
            d_ptr->mFirmwareVersion = val.value().value<QString>();
        }
    }
}

XS__Sdk_version_t::XS__Sdk_version_t()
    : d_ptr(new PrivateDPtr)
{
}

XS__Sdk_version_t::~XS__Sdk_version_t()
{
}

XS__Sdk_version_t::XS__Sdk_version_t( const XS__Sdk_version_t& other )
    : d_ptr( other.d_ptr )
{
}

XS__Sdk_version_t&  XS__Sdk_version_t::operator=( const XS__Sdk_version_t& other )
{
    if ( this == &other )
        return *this;

    d_ptr = other.d_ptr;

    return *this;
}


AddModifyUserJob::AddModifyUserJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mUser(), mResultAddModifyUserResponse()
{
}

void AddModifyUserJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t AddModifyUserJob::userCredentials() const
{
    return mUserCredentials;
}

void AddModifyUserJob::setUser( const XS__Sdk_user_t& arg0 )
{
    mUser = arg0;
}

XS__Sdk_user_t AddModifyUserJob::user() const
{
    return mUser;
}

void AddModifyUserJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addModifyUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUser(mUser.serialize(QString::fromLatin1("user")));
    _valueUser.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUser);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("addModifyUser"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_user_add_modify_remove_Response_t AddModifyUserJob::addModifyUserResponse() const
{
    return mResultAddModifyUserResponse;
}

void AddModifyUserJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultAddModifyUserResponse.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


AddNewContactJob::AddNewContactJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mName(), mNumber(), mIsFavourite(), mResultAddContactResult()
{
}

void AddNewContactJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t AddNewContactJob::userCredentials() const
{
    return mUserCredentials;
}

void AddNewContactJob::setName( const QString& arg0 )
{
    mName = arg0;
}

QString AddNewContactJob::name() const
{
    return mName;
}

void AddNewContactJob::setNumber( const QString& arg0 )
{
    mNumber = arg0;
}

QString AddNewContactJob::number() const
{
    return mNumber;
}

void AddNewContactJob::setIsFavourite( bool arg0 )
{
    mIsFavourite = arg0;
}

bool AddNewContactJob::isFavourite() const
{
    return mIsFavourite;
}

void AddNewContactJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addNewContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(mName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueName);
    KDSoapValue _valueNumber(QString::fromLatin1("number"), QVariant::fromValue(mNumber), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueNumber.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueNumber);
    KDSoapValue _valueIsFavourite(QString::fromLatin1("isFavourite"), QVariant::fromValue(mIsFavourite), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueIsFavourite.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueIsFavourite);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("addNewContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_contact_add_modify_remove_Response_t AddNewContactJob::addContactResult() const
{
    return mResultAddContactResult;
}

void AddNewContactJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultAddContactResult.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetContactListJob::GetContactListJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mResultContactList()
{
}

void GetContactListJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t GetContactListJob::userCredentials() const
{
    return mUserCredentials;
}

void GetContactListJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getContactList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getContactList"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_contacts_getList_Response_t GetContactListJob::contactList() const
{
    return mResultContactList;
}

void GetContactListJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultContactList.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetSettingsJob::GetSettingsJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mReqList(), mResultConfigs()
{
}

void GetSettingsJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t GetSettingsJob::userCredentials() const
{
    return mUserCredentials;
}

void GetSettingsJob::setReqList( const XS__Sdk_configuration_requestList_t& arg0 )
{
    mReqList = arg0;
}

XS__Sdk_configuration_requestList_t GetSettingsJob::reqList() const
{
    return mReqList;
}

void GetSettingsJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueReqList(mReqList.serialize(QString::fromLatin1("reqList")));
    _valueReqList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueReqList);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getSettings"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_configuration_getSettings_response_t GetSettingsJob::configs() const
{
    return mResultConfigs;
}

void GetSettingsJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultConfigs.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetStatusJob::GetStatusJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mRequest(), mResultStatusOutput()
{
}

void GetStatusJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t GetStatusJob::userCredentials() const
{
    return mUserCredentials;
}

void GetStatusJob::setRequest( const XS__Sdk_status_request_t& arg0 )
{
    mRequest = arg0;
}

XS__Sdk_status_request_t GetStatusJob::request() const
{
    return mRequest;
}

void GetStatusJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getStatus");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueRequest(mRequest.serialize(QString::fromLatin1("request")));
    _valueRequest.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueRequest);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getStatus"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_status_get_response_t GetStatusJob::statusOutput() const
{
    return mResultStatusOutput;
}

void GetStatusJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultStatusOutput.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetTransceiverInfoJob::GetTransceiverInfoJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mResultTransceiverInfo()
{
}

void GetTransceiverInfoJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getTransceiverInfo");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getTransceiverInfo"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_status_get_response_t GetTransceiverInfoJob::transceiverInfo() const
{
    return mResultTransceiverInfo;
}

void GetTransceiverInfoJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultTransceiverInfo.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetUserDetailsJob::GetUserDetailsJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mResultLogin()
{
}

void GetUserDetailsJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t GetUserDetailsJob::userCredentials() const
{
    return mUserCredentials;
}

void GetUserDetailsJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserDetails");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getUserDetails"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_user_details_response_t GetUserDetailsJob::login() const
{
    return mResultLogin;
}

void GetUserDetailsJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultLogin.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetUserListJob::GetUserListJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mResultGetUserListResponse()
{
}

void GetUserListJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t GetUserListJob::userCredentials() const
{
    return mUserCredentials;
}

void GetUserListJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getUserList"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_user_getList_Response_t GetUserListJob::getUserListResponse() const
{
    return mResultGetUserListResponse;
}

void GetUserListJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultGetUserListResponse.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


GetVersionJob::GetVersionJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mResultVersionNumber()
{
}

void GetVersionJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getVersion");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("getVersion"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_version_t GetVersionJob::versionNumber() const
{
    return mResultVersionNumber;
}

void GetVersionJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultVersionNumber.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


ModifyContactJob::ModifyContactJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mContact(), mResultModifyContactResult()
{
}

void ModifyContactJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t ModifyContactJob::userCredentials() const
{
    return mUserCredentials;
}

void ModifyContactJob::setContact( const XS__Sdk_contact_t& arg0 )
{
    mContact = arg0;
}

XS__Sdk_contact_t ModifyContactJob::contact() const
{
    return mContact;
}

void ModifyContactJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/modifyContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContact(mContact.serialize(QString::fromLatin1("contact")));
    _valueContact.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContact);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("modifyContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_contact_add_modify_remove_Response_t ModifyContactJob::modifyContactResult() const
{
    return mResultModifyContactResult;
}

void ModifyContactJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultModifyContactResult.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


PerformTaskJob::PerformTaskJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mTaskList(), mResultParameters()
{
}

void PerformTaskJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t PerformTaskJob::userCredentials() const
{
    return mUserCredentials;
}

void PerformTaskJob::setTaskList( const XS__Sdk_task_requestList_t& arg0 )
{
    mTaskList = arg0;
}

XS__Sdk_task_requestList_t PerformTaskJob::taskList() const
{
    return mTaskList;
}

void PerformTaskJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/performTask");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueTaskList(mTaskList.serialize(QString::fromLatin1("taskList")));
    _valueTaskList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueTaskList);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("performTask"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_task_perform_response_t PerformTaskJob::parameters() const
{
    return mResultParameters;
}

void PerformTaskJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultParameters.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


RemoveContactJob::RemoveContactJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mContactID(), mResultRemoveContactResult()
{
}

void RemoveContactJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t RemoveContactJob::userCredentials() const
{
    return mUserCredentials;
}

void RemoveContactJob::setContactID( int arg0 )
{
    mContactID = arg0;
}

int RemoveContactJob::contactID() const
{
    return mContactID;
}

void RemoveContactJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContactID(QString::fromLatin1("contactID"), QVariant::fromValue(mContactID), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueContactID.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContactID);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("removeContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_contact_add_modify_remove_Response_t RemoveContactJob::removeContactResult() const
{
    return mResultRemoveContactResult;
}

void RemoveContactJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultRemoveContactResult.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


RemoveUserJob::RemoveUserJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mUserName(), mResultRemoveUserResponse()
{
}

void RemoveUserJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t RemoveUserJob::userCredentials() const
{
    return mUserCredentials;
}

void RemoveUserJob::setUserName( const QString& arg0 )
{
    mUserName = arg0;
}

QString RemoveUserJob::userName() const
{
    return mUserName;
}

void RemoveUserJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUserName(QString::fromLatin1("userName"), QVariant::fromValue(mUserName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueUserName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserName);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("removeUser"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_user_add_modify_remove_Response_t RemoveUserJob::removeUserResponse() const
{
    return mResultRemoveUserResponse;
}

void RemoveUserJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultRemoveUserResponse.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


SetSettingsJob::SetSettingsJob( Sdk* service, QObject* _parent )
    : KDSoapJob(_parent), mService(service), mUserCredentials(), mSetList(), mResultSetSettingsResponse()
{
}

void SetSettingsJob::setUserCredentials( const XS__Sdk_user_credentials_t& arg0 )
{
    mUserCredentials = arg0;
}

XS__Sdk_user_credentials_t SetSettingsJob::userCredentials() const
{
    return mUserCredentials;
}

void SetSettingsJob::setSetList( const XS__Sdk_configuration_setRequst_list_t& arg0 )
{
    mSetList = arg0;
}

XS__Sdk_configuration_setRequst_list_t SetSettingsJob::setList() const
{
    return mSetList;
}

void SetSettingsJob::doStart()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/setSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(mUserCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueSetList(mSetList.serialize(QString::fromLatin1("setList")));
    _valueSetList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueSetList);
    KDSoapPendingCall pendingCall = mService->clientInterface()->asyncCall(QLatin1String("setSettings"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(slotFinished(KDSoapPendingCallWatcher*)));
}

XS__Sdk_configuration_setSettings_response_t SetSettingsJob::setSettingsResponse() const
{
    return mResultSetSettingsResponse;
}

void SetSettingsJob::slotFinished( KDSoapPendingCallWatcher* watcher )
{
    watcher->deleteLater();
    KDSoapMessage _reply = watcher->returnMessage();
    if (!_reply.isFault()) {
        if (_reply.childValues().isEmpty()) {
            _reply.setFault(true);
            _reply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
            return;
        }
        _reply = _reply.childValues().at(0);
        mResultSetSettingsResponse.deserialize(_reply);
    }
    emitFinished(_reply, watcher->returnHeaders());
}


class Sdk::PrivateDPtr
{
public:
    PrivateDPtr();

public:
    KDSoapClientInterface *m_clientInterface;
    KDSoapMessage m_lastReply;
    QString m_endPoint;
};

Sdk::PrivateDPtr::PrivateDPtr()
    : m_clientInterface(NULL)
{
}


Sdk::Sdk( QObject* _parent )
    : QObject(_parent), d_ptr(new PrivateDPtr)
{
}

Sdk::~Sdk()
{
    delete d_ptr->m_clientInterface;

    delete d_ptr;
    d_ptr = 0;
}

void Sdk::ignoreSslErrors()
{
    clientInterface()->ignoreSslErrors();
}

void Sdk::setEndPoint( const QString& endPoint )
{
    d_ptr->m_endPoint = endPoint;
    if (d_ptr->m_clientInterface)
        d_ptr->m_clientInterface->setEndPoint( endPoint );
}

void Sdk::setSoapVersion( KDSoapClientInterface::SoapVersion soapVersion )
{
    clientInterface()->setSoapVersion(soapVersion);
}

int Sdk::lastErrorCode() const
{
    if (d_ptr->m_lastReply.isFault())
        return d_ptr->m_lastReply.childValues().child(QLatin1String("faultcode")).value().toInt();
    return 0;
}

QString Sdk::lastError() const
{
    if (d_ptr->m_lastReply.isFault())
        return d_ptr->m_lastReply.faultAsString();
    return QString();
}

const KDSoapClientInterface *Sdk::clientInterface() const
{
    if (!d_ptr->m_clientInterface) {
        const QString endPoint = !d_ptr->m_endPoint.isEmpty() ? d_ptr->m_endPoint : QString::fromLatin1("http://iridiumgo.lan/sdk/sdk.php");
        const QString messageNamespace = QString::fromLatin1("http://iridiumgo.lan/sdk/");
        d_ptr->m_clientInterface = new KDSoapClientInterface(endPoint, messageNamespace);
        d_ptr->m_clientInterface->setSoapVersion( KDSoapClientInterface::SOAP1_1 );
    }
    return d_ptr->m_clientInterface;
}

KDSoapClientInterface *Sdk::clientInterface()
{
    return const_cast<KDSoapClientInterface*>( const_cast< const Sdk*>( this )->clientInterface() );
}

XS__Sdk_version_t Sdk::getVersion()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getVersion");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getVersion"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_version_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_version_t();
    }
    XS__Sdk_version_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetVersion()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getVersion");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getVersion"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetVersionFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetVersionFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getVersionError(reply);
        Q_EMIT soapError(QLatin1String("getVersion"), reply);
    } else {
        XS__Sdk_version_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("versionNumber")));
        Q_EMIT getVersionDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_user_details_response_t Sdk::getUserDetails( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserDetails");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getUserDetails"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_user_details_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_user_details_response_t();
    }
    XS__Sdk_user_details_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetUserDetails( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserDetails");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getUserDetails"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetUserDetailsFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetUserDetailsFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getUserDetailsError(reply);
        Q_EMIT soapError(QLatin1String("getUserDetails"), reply);
    } else {
        XS__Sdk_user_details_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("login")));
        Q_EMIT getUserDetailsDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_status_get_response_t Sdk::getStatus( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_status_request_t& request )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getStatus");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueRequest(request.serialize(QString::fromLatin1("request")));
    _valueRequest.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueRequest);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getStatus"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_status_get_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_status_get_response_t();
    }
    XS__Sdk_status_get_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetStatus( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_status_request_t& request )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getStatus");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueRequest(request.serialize(QString::fromLatin1("request")));
    _valueRequest.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueRequest);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getStatus"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetStatusFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetStatusFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getStatusError(reply);
        Q_EMIT soapError(QLatin1String("getStatus"), reply);
    } else {
        XS__Sdk_status_get_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("statusOutput")));
        Q_EMIT getStatusDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_configuration_getSettings_response_t Sdk::getSettings( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_configuration_requestList_t& reqList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueReqList(reqList.serialize(QString::fromLatin1("reqList")));
    _valueReqList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueReqList);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getSettings"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_configuration_getSettings_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_configuration_getSettings_response_t();
    }
    XS__Sdk_configuration_getSettings_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetSettings( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_configuration_requestList_t& reqList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueReqList(reqList.serialize(QString::fromLatin1("reqList")));
    _valueReqList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueReqList);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getSettings"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetSettingsFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetSettingsFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getSettingsError(reply);
        Q_EMIT soapError(QLatin1String("getSettings"), reply);
    } else {
        XS__Sdk_configuration_getSettings_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("configs")));
        Q_EMIT getSettingsDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_configuration_setSettings_response_t Sdk::setSettings( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_configuration_setRequst_list_t& setList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/setSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueSetList(setList.serialize(QString::fromLatin1("setList")));
    _valueSetList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueSetList);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("setSettings"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_configuration_setSettings_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_configuration_setSettings_response_t();
    }
    XS__Sdk_configuration_setSettings_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncSetSettings( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_configuration_setRequst_list_t& setList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/setSettings");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueSetList(setList.serialize(QString::fromLatin1("setList")));
    _valueSetList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueSetList);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("setSettings"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotSetSettingsFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotSetSettingsFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT setSettingsError(reply);
        Q_EMIT soapError(QLatin1String("setSettings"), reply);
    } else {
        XS__Sdk_configuration_setSettings_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("setSettingsResponse")));
        Q_EMIT setSettingsDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_task_perform_response_t Sdk::performTask( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_task_requestList_t& taskList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/performTask");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueTaskList(taskList.serialize(QString::fromLatin1("taskList")));
    _valueTaskList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueTaskList);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("performTask"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_task_perform_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_task_perform_response_t();
    }
    XS__Sdk_task_perform_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncPerformTask( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_task_requestList_t& taskList )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/performTask");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueTaskList(taskList.serialize(QString::fromLatin1("taskList")));
    _valueTaskList.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueTaskList);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("performTask"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotPerformTaskFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotPerformTaskFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT performTaskError(reply);
        Q_EMIT soapError(QLatin1String("performTask"), reply);
    } else {
        XS__Sdk_task_perform_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("parameters")));
        Q_EMIT performTaskDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_user_getList_Response_t Sdk::getUserList( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getUserList"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_user_getList_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_user_getList_Response_t();
    }
    XS__Sdk_user_getList_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetUserList( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getUserList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getUserList"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetUserListFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetUserListFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getUserListError(reply);
        Q_EMIT soapError(QLatin1String("getUserList"), reply);
    } else {
        XS__Sdk_user_getList_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("getUserListResponse")));
        Q_EMIT getUserListDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_user_add_modify_remove_Response_t Sdk::addModifyUser( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_user_t& user )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addModifyUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUser(user.serialize(QString::fromLatin1("user")));
    _valueUser.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUser);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("addModifyUser"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_user_add_modify_remove_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_user_add_modify_remove_Response_t();
    }
    XS__Sdk_user_add_modify_remove_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncAddModifyUser( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_user_t& user )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addModifyUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUser(user.serialize(QString::fromLatin1("user")));
    _valueUser.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUser);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("addModifyUser"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotAddModifyUserFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotAddModifyUserFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT addModifyUserError(reply);
        Q_EMIT soapError(QLatin1String("addModifyUser"), reply);
    } else {
        XS__Sdk_user_add_modify_remove_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("addModifyUserResponse")));
        Q_EMIT addModifyUserDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_user_add_modify_remove_Response_t Sdk::removeUser( const XS__Sdk_user_credentials_t& userCredentials, const QString& userName )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUserName(QString::fromLatin1("userName"), QVariant::fromValue(userName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueUserName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserName);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("removeUser"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_user_add_modify_remove_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_user_add_modify_remove_Response_t();
    }
    XS__Sdk_user_add_modify_remove_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncRemoveUser( const XS__Sdk_user_credentials_t& userCredentials, const QString& userName )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeUser");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueUserName(QString::fromLatin1("userName"), QVariant::fromValue(userName), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueUserName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserName);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("removeUser"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotRemoveUserFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotRemoveUserFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT removeUserError(reply);
        Q_EMIT soapError(QLatin1String("removeUser"), reply);
    } else {
        XS__Sdk_user_add_modify_remove_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("removeUserResponse")));
        Q_EMIT removeUserDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_contacts_getList_Response_t Sdk::getContactList( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getContactList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getContactList"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_contacts_getList_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_contacts_getList_Response_t();
    }
    XS__Sdk_contacts_getList_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetContactList( const XS__Sdk_user_credentials_t& userCredentials )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getContactList");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getContactList"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetContactListFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetContactListFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getContactListError(reply);
        Q_EMIT soapError(QLatin1String("getContactList"), reply);
    } else {
        XS__Sdk_contacts_getList_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("contactList")));
        Q_EMIT getContactListDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_contact_add_modify_remove_Response_t Sdk::addNewContact( const XS__Sdk_user_credentials_t& userCredentials, const QString& name, const QString& number, bool isFavourite )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addNewContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(name), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueName);
    KDSoapValue _valueNumber(QString::fromLatin1("number"), QVariant::fromValue(number), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueNumber.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueNumber);
    KDSoapValue _valueIsFavourite(QString::fromLatin1("isFavourite"), QVariant::fromValue(isFavourite), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueIsFavourite.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueIsFavourite);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("addNewContact"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_contact_add_modify_remove_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_contact_add_modify_remove_Response_t();
    }
    XS__Sdk_contact_add_modify_remove_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncAddNewContact( const XS__Sdk_user_credentials_t& userCredentials, const QString& name, const QString& number, bool isFavourite )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/addNewContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueName(QString::fromLatin1("name"), QVariant::fromValue(name), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueName.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueName);
    KDSoapValue _valueNumber(QString::fromLatin1("number"), QVariant::fromValue(number), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("string"));
    _valueNumber.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueNumber);
    KDSoapValue _valueIsFavourite(QString::fromLatin1("isFavourite"), QVariant::fromValue(isFavourite), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("boolean"));
    _valueIsFavourite.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueIsFavourite);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("addNewContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotAddNewContactFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotAddNewContactFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT addNewContactError(reply);
        Q_EMIT soapError(QLatin1String("addNewContact"), reply);
    } else {
        XS__Sdk_contact_add_modify_remove_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("addContactResult")));
        Q_EMIT addNewContactDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_contact_add_modify_remove_Response_t Sdk::modifyContact( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_contact_t& contact )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/modifyContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContact(contact.serialize(QString::fromLatin1("contact")));
    _valueContact.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContact);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("modifyContact"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_contact_add_modify_remove_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_contact_add_modify_remove_Response_t();
    }
    XS__Sdk_contact_add_modify_remove_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncModifyContact( const XS__Sdk_user_credentials_t& userCredentials, const XS__Sdk_contact_t& contact )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/modifyContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContact(contact.serialize(QString::fromLatin1("contact")));
    _valueContact.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContact);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("modifyContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotModifyContactFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotModifyContactFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT modifyContactError(reply);
        Q_EMIT soapError(QLatin1String("modifyContact"), reply);
    } else {
        XS__Sdk_contact_add_modify_remove_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("modifyContactResult")));
        Q_EMIT modifyContactDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_contact_add_modify_remove_Response_t Sdk::removeContact( const XS__Sdk_user_credentials_t& userCredentials, int contactID )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContactID(QString::fromLatin1("contactID"), QVariant::fromValue(contactID), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueContactID.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContactID);
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("removeContact"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_contact_add_modify_remove_Response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_contact_add_modify_remove_Response_t();
    }
    XS__Sdk_contact_add_modify_remove_Response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncRemoveContact( const XS__Sdk_user_credentials_t& userCredentials, int contactID )
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/removeContact");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapValue _valueUserCredentials(userCredentials.serialize(QString::fromLatin1("userCredentials")));
    _valueUserCredentials.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueUserCredentials);
    KDSoapValue _valueContactID(QString::fromLatin1("contactID"), QVariant::fromValue(contactID), KDSoapNamespaceManager::xmlSchema2001(), QString::fromLatin1("int"));
    _valueContactID.setNamespaceUri(QString::fromLatin1(""));
    message.childValues().append(_valueContactID);
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("removeContact"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotRemoveContactFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotRemoveContactFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT removeContactError(reply);
        Q_EMIT soapError(QLatin1String("removeContact"), reply);
    } else {
        XS__Sdk_contact_add_modify_remove_Response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("removeContactResult")));
        Q_EMIT removeContactDone( ret );
    }
    watcher->deleteLater();
}

XS__Sdk_status_get_response_t Sdk::getTransceiverInfo()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getTransceiverInfo");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    d_ptr->m_lastReply = clientInterface()->call(QLatin1String("getTransceiverInfo"), message, action);
    if (d_ptr->m_lastReply.isFault())
        return XS__Sdk_status_get_response_t();
    if (d_ptr->m_lastReply.childValues().isEmpty()) {
        d_ptr->m_lastReply.setFault(true);
        d_ptr->m_lastReply.addArgument(QString::fromLatin1("faultcode"), QString::fromLatin1("Server.EmptyResponse"));
        return XS__Sdk_status_get_response_t();
    }
    XS__Sdk_status_get_response_t ret;
    const KDSoapValue val = d_ptr->m_lastReply.childValues().at(0);
    ret.deserialize(val);
    return ret;
}

void Sdk::asyncGetTransceiverInfo()
{
    const QString action = QString::fromLatin1("http://iridiumgo.lan/sdk/getTransceiverInfo");
    KDSoapMessage message;
    message.setUse(KDSoapMessage::LiteralUse);
    message.setNamespaceUri(QString::fromLatin1("http://iridiumgo.lan/sdk/"));
    KDSoapPendingCall pendingCall = clientInterface()->asyncCall(QLatin1String("getTransceiverInfo"), message, action);
    KDSoapPendingCallWatcher *watcher = new KDSoapPendingCallWatcher(pendingCall, this);
    QObject::connect(watcher, SIGNAL(finished(KDSoapPendingCallWatcher*)),
                     this, SLOT(_kd_slotGetTransceiverInfoFinished(KDSoapPendingCallWatcher*)));
}

void Sdk::_kd_slotGetTransceiverInfoFinished( KDSoapPendingCallWatcher* watcher )
{
    const KDSoapMessage reply = watcher->returnMessage();
    if (reply.isFault()) {
        Q_EMIT getTransceiverInfoError(reply);
        Q_EMIT soapError(QLatin1String("getTransceiverInfo"), reply);
    } else {
        XS__Sdk_status_get_response_t ret;
        ret.deserialize(reply.childValues().child(QLatin1String("transceiverInfo")));
        Q_EMIT getTransceiverInfoDone( ret );
    }
    watcher->deleteLater();
}