// This file is generated by kconfig_compiler_kf5 from mailtransport.kcfg.
// All changes you do to this file will be lost.
#ifndef MAILTRANSPORT_TRANSPORTBASE_H
#define MAILTRANSPORT_TRANSPORTBASE_H

#include "mailtransport_export.h"
#include <KLocalizedString>

#include <kconfigskeleton.h>
#include <QCoreApplication>
#include <QDebug>

namespace MailTransport {

class MAILTRANSPORT_EXPORT TransportBase : public KConfigSkeleton
{
  Q_OBJECT
  public:
    enum EnumEncryption { None, SSL, TLS };
    Q_ENUM(EnumEncryption)
    enum EnumAuthenticationType { LOGIN, PLAIN, CRAM_MD5, DIGEST_MD5, GSSAPI, NTLM, APOP, CLEAR, ANONYMOUS, XOAUTH2 };
    Q_ENUM(EnumAuthenticationType)

    TransportBase( const QString & transportId );
    ~TransportBase() override;

    /**
      Set Unique identifier
    */
    void setId( int v )
    {
      if (v != mId && !isIdImmutable()) {
        mId = v;
        Q_EMIT idChanged();
      }
    }

    Q_PROPERTY(int id READ id WRITE setId NOTIFY idChanged)
    Q_PROPERTY(bool isIdImmutable READ isIdImmutable CONSTANT)
    /**
      Get Unique identifier
    */
    int id() const
    {
      return mId;
    }

    /**
      Is Unique identifier Immutable
    */
    bool isIdImmutable() const
    {
      return isImmutable( QStringLiteral( "id" ) );
    }

    /**
      Get Item object corresponding to id()
    */
    KConfigCompilerSignallingItem *idItem()
    {
      return mIdItem;
    }

    /**
      Set User-visible transport name
    */
    void setName( const QString & v )
    {
      if (v != mName && !isNameImmutable()) {
        mName = v;
        Q_EMIT nameChanged();
      }
    }

    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
    Q_PROPERTY(bool isNameImmutable READ isNameImmutable CONSTANT)
    /**
      Get User-visible transport name
    */
    QString name() const
    {
      return mName;
    }

    /**
      Is User-visible transport name Immutable
    */
    bool isNameImmutable() const
    {
      return isImmutable( QStringLiteral( "name" ) );
    }

    /**
      Get Item object corresponding to name()
    */
    KConfigCompilerSignallingItem *nameItem()
    {
      return mNameItem;
    }

    /**
      Set identifier
    */
    void setIdentifier( const QString & v )
    {
      if (v != mIdentifier && !isIdentifierImmutable()) {
        mIdentifier = v;
        Q_EMIT identifierChanged();
      }
    }

    Q_PROPERTY(QString identifier READ identifier WRITE setIdentifier NOTIFY identifierChanged)
    Q_PROPERTY(bool isIdentifierImmutable READ isIdentifierImmutable CONSTANT)
    /**
      Get identifier
    */
    QString identifier() const
    {
      return mIdentifier;
    }

    /**
      Is identifier Immutable
    */
    bool isIdentifierImmutable() const
    {
      return isImmutable( QStringLiteral( "identifier" ) );
    }

    /**
      Get Item object corresponding to identifier()
    */
    KConfigCompilerSignallingItem *identifierItem()
    {
      return mIdentifierItem;
    }

    /**
      Set Host name of the server
    */
    void setHost( const QString & v )
    {
      if (v != mHost && !isHostImmutable()) {
        mHost = v;
        Q_EMIT hostChanged();
      }
    }

    Q_PROPERTY(QString host READ host WRITE setHost NOTIFY hostChanged)
    Q_PROPERTY(bool isHostImmutable READ isHostImmutable CONSTANT)
    /**
      Get Host name of the server
    */
    QString host() const
    {
      return mHost;
    }

    /**
      Is Host name of the server Immutable
    */
    bool isHostImmutable() const
    {
      return isImmutable( QStringLiteral( "host" ) );
    }

    /**
      Get Item object corresponding to host()
    */
    KConfigCompilerSignallingItem *hostItem()
    {
      return mHostItem;
    }

    /**
      Set Port number of the server
    */
    void setPort( uint v )
    {
      if (v != mPort && !isPortImmutable()) {
        mPort = v;
        Q_EMIT portChanged();
      }
    }

    Q_PROPERTY(uint port READ port WRITE setPort NOTIFY portChanged)
    Q_PROPERTY(bool isPortImmutable READ isPortImmutable CONSTANT)
    /**
      Get Port number of the server
    */
    uint port() const
    {
      return mPort;
    }

    /**
      Is Port number of the server Immutable
    */
    bool isPortImmutable() const
    {
      return isImmutable( QStringLiteral( "port" ) );
    }

    /**
      Get Item object corresponding to port()
    */
    KConfigCompilerSignallingItem *portItem()
    {
      return mPortItem;
    }

    /**
      Set User name needed for login
    */
    void setUserName( const QString & v )
    {
      if (v != mUserName && !isUserNameImmutable()) {
        mUserName = v;
        Q_EMIT userNameChanged();
      }
    }

    Q_PROPERTY(QString userName READ userName WRITE setUserName NOTIFY userNameChanged)
    Q_PROPERTY(bool isUserNameImmutable READ isUserNameImmutable CONSTANT)
    /**
      Get User name needed for login
    */
    QString userName() const
    {
      return mUserName;
    }

    /**
      Is User name needed for login Immutable
    */
    bool isUserNameImmutable() const
    {
      return isImmutable( QStringLiteral( "userName" ) );
    }

    /**
      Get Item object corresponding to userName()
    */
    KConfigCompilerSignallingItem *userNameItem()
    {
      return mUserNameItem;
    }

    /**
      Set Command to execute before sending a mail
    */
    void setPrecommand( const QString & v )
    {
      if (v != mPrecommand && !isPrecommandImmutable()) {
        mPrecommand = v;
        Q_EMIT precommandChanged();
      }
    }

    Q_PROPERTY(QString precommand READ precommand WRITE setPrecommand NOTIFY precommandChanged)
    Q_PROPERTY(bool isPrecommandImmutable READ isPrecommandImmutable CONSTANT)
    /**
      Get Command to execute before sending a mail
    */
    QString precommand() const
    {
      return mPrecommand;
    }

    /**
      Is Command to execute before sending a mail Immutable
    */
    bool isPrecommandImmutable() const
    {
      return isImmutable( QStringLiteral( "precommand" ) );
    }

    /**
      Get Item object corresponding to precommand()
    */
    KConfigCompilerSignallingItem *precommandItem()
    {
      return mPrecommandItem;
    }

    /**
      Set Options added to mailtransport method
    */
    void setOptions( const QString & v )
    {
      if (v != mOptions && !isOptionsImmutable()) {
        mOptions = v;
        Q_EMIT optionsChanged();
      }
    }

    Q_PROPERTY(QString options READ options WRITE setOptions NOTIFY optionsChanged)
    Q_PROPERTY(bool isOptionsImmutable READ isOptionsImmutable CONSTANT)
    /**
      Get Options added to mailtransport method
    */
    QString options() const
    {
      return mOptions;
    }

    /**
      Is Options added to mailtransport method Immutable
    */
    bool isOptionsImmutable() const
    {
      return isImmutable( QStringLiteral( "options" ) );
    }

    /**
      Get Item object corresponding to options()
    */
    KConfigCompilerSignallingItem *optionsItem()
    {
      return mOptionsItem;
    }

    /**
      Set Server requires authentication
    */
    void setRequiresAuthentication( bool v )
    {
      if (v != mRequiresAuthentication && !isRequiresAuthenticationImmutable()) {
        mRequiresAuthentication = v;
        Q_EMIT requiresAuthenticationChanged();
      }
    }

    Q_PROPERTY(bool requiresAuthentication READ requiresAuthentication WRITE setRequiresAuthentication NOTIFY requiresAuthenticationChanged)
    Q_PROPERTY(bool isRequiresAuthenticationImmutable READ isRequiresAuthenticationImmutable CONSTANT)
    /**
      Get Server requires authentication
    */
    bool requiresAuthentication() const
    {
      return mRequiresAuthentication;
    }

    /**
      Is Server requires authentication Immutable
    */
    bool isRequiresAuthenticationImmutable() const
    {
      return isImmutable( QStringLiteral( "requiresAuthentication" ) );
    }

    /**
      Get Item object corresponding to requiresAuthentication()
    */
    KConfigCompilerSignallingItem *requiresAuthenticationItem()
    {
      return mRequiresAuthenticationItem;
    }

    /**
      Set Store password
    */
    void setStorePassword( bool v )
    {
      if (v != mStorePassword && !isStorePasswordImmutable()) {
        mStorePassword = v;
        Q_EMIT storePasswordChanged();
      }
    }

    Q_PROPERTY(bool storePassword READ storePassword WRITE setStorePassword NOTIFY storePasswordChanged)
    Q_PROPERTY(bool isStorePasswordImmutable READ isStorePasswordImmutable CONSTANT)
    /**
      Get Store password
    */
    bool storePassword() const
    {
      return mStorePassword;
    }

    /**
      Is Store password Immutable
    */
    bool isStorePasswordImmutable() const
    {
      return isImmutable( QStringLiteral( "storePassword" ) );
    }

    /**
      Get Item object corresponding to storePassword()
    */
    KConfigCompilerSignallingItem *storePasswordItem()
    {
      return mStorePasswordItem;
    }

    /**
      Set Encryption method used for communication
    */
    void setEncryption( int v )
    {
      if (v != mEncryption && !isEncryptionImmutable()) {
        mEncryption = v;
        Q_EMIT encryptionChanged();
      }
    }

    Q_PROPERTY(int encryption READ encryption WRITE setEncryption NOTIFY encryptionChanged)
    Q_PROPERTY(bool isEncryptionImmutable READ isEncryptionImmutable CONSTANT)
    /**
      Get Encryption method used for communication
    */
    int encryption() const
    {
      return mEncryption;
    }

    /**
      Is Encryption method used for communication Immutable
    */
    bool isEncryptionImmutable() const
    {
      return isImmutable( QStringLiteral( "encryption" ) );
    }

    /**
      Get Item object corresponding to encryption()
    */
    KConfigCompilerSignallingItem *encryptionItem()
    {
      return mEncryptionItem;
    }

    /**
      Set Authentication method
    */
    void setAuthenticationType( int v )
    {
      if (v != mAuthenticationType && !isAuthenticationTypeImmutable()) {
        mAuthenticationType = v;
        Q_EMIT authenticationTypeChanged();
      }
    }

    Q_PROPERTY(int authenticationType READ authenticationType WRITE setAuthenticationType NOTIFY authenticationTypeChanged)
    Q_PROPERTY(bool isAuthenticationTypeImmutable READ isAuthenticationTypeImmutable CONSTANT)
    /**
      Get Authentication method
    */
    int authenticationType() const
    {
      return mAuthenticationType;
    }

    /**
      Is Authentication method Immutable
    */
    bool isAuthenticationTypeImmutable() const
    {
      return isImmutable( QStringLiteral( "authenticationType" ) );
    }

    /**
      Get Item object corresponding to authenticationType()
    */
    KConfigCompilerSignallingItem *authenticationTypeItem()
    {
      return mAuthenticationTypeItem;
    }

    /**
      Set specifyHostname
    */
    void setSpecifyHostname( bool v )
    {
      if (v != mSpecifyHostname && !isSpecifyHostnameImmutable()) {
        mSpecifyHostname = v;
        Q_EMIT specifyHostnameChanged();
      }
    }

    Q_PROPERTY(bool specifyHostname READ specifyHostname WRITE setSpecifyHostname NOTIFY specifyHostnameChanged)
    Q_PROPERTY(bool isSpecifyHostnameImmutable READ isSpecifyHostnameImmutable CONSTANT)
    /**
      Get specifyHostname
    */
    bool specifyHostname() const
    {
      return mSpecifyHostname;
    }

    /**
      Is specifyHostname Immutable
    */
    bool isSpecifyHostnameImmutable() const
    {
      return isImmutable( QStringLiteral( "specifyHostname" ) );
    }

    /**
      Get Item object corresponding to specifyHostname()
    */
    KConfigCompilerSignallingItem *specifyHostnameItem()
    {
      return mSpecifyHostnameItem;
    }

    /**
      Set localHostname
    */
    void setLocalHostname( const QString & v )
    {
      if (v != mLocalHostname && !isLocalHostnameImmutable()) {
        mLocalHostname = v;
        Q_EMIT localHostnameChanged();
      }
    }

    Q_PROPERTY(QString localHostname READ localHostname WRITE setLocalHostname NOTIFY localHostnameChanged)
    Q_PROPERTY(bool isLocalHostnameImmutable READ isLocalHostnameImmutable CONSTANT)
    /**
      Get localHostname
    */
    QString localHostname() const
    {
      return mLocalHostname;
    }

    /**
      Is localHostname Immutable
    */
    bool isLocalHostnameImmutable() const
    {
      return isImmutable( QStringLiteral( "localHostname" ) );
    }

    /**
      Get Item object corresponding to localHostname()
    */
    KConfigCompilerSignallingItem *localHostnameItem()
    {
      return mLocalHostnameItem;
    }

    /**
      Set specifySenderOverwriteAddress
    */
    void setSpecifySenderOverwriteAddress( bool v )
    {
      if (v != mSpecifySenderOverwriteAddress && !isSpecifySenderOverwriteAddressImmutable()) {
        mSpecifySenderOverwriteAddress = v;
        Q_EMIT specifySenderOverwriteAddressChanged();
      }
    }

    Q_PROPERTY(bool specifySenderOverwriteAddress READ specifySenderOverwriteAddress WRITE setSpecifySenderOverwriteAddress NOTIFY specifySenderOverwriteAddressChanged)
    Q_PROPERTY(bool isSpecifySenderOverwriteAddressImmutable READ isSpecifySenderOverwriteAddressImmutable CONSTANT)
    /**
      Get specifySenderOverwriteAddress
    */
    bool specifySenderOverwriteAddress() const
    {
      return mSpecifySenderOverwriteAddress;
    }

    /**
      Is specifySenderOverwriteAddress Immutable
    */
    bool isSpecifySenderOverwriteAddressImmutable() const
    {
      return isImmutable( QStringLiteral( "specifySenderOverwriteAddress" ) );
    }

    /**
      Get Item object corresponding to specifySenderOverwriteAddress()
    */
    KConfigCompilerSignallingItem *specifySenderOverwriteAddressItem()
    {
      return mSpecifySenderOverwriteAddressItem;
    }

    /**
      Set senderOverwriteAddress
    */
    void setSenderOverwriteAddress( const QString & v )
    {
      if (v != mSenderOverwriteAddress && !isSenderOverwriteAddressImmutable()) {
        mSenderOverwriteAddress = v;
        Q_EMIT senderOverwriteAddressChanged();
      }
    }

    Q_PROPERTY(QString senderOverwriteAddress READ senderOverwriteAddress WRITE setSenderOverwriteAddress NOTIFY senderOverwriteAddressChanged)
    Q_PROPERTY(bool isSenderOverwriteAddressImmutable READ isSenderOverwriteAddressImmutable CONSTANT)
    /**
      Get senderOverwriteAddress
    */
    QString senderOverwriteAddress() const
    {
      return mSenderOverwriteAddress;
    }

    /**
      Is senderOverwriteAddress Immutable
    */
    bool isSenderOverwriteAddressImmutable() const
    {
      return isImmutable( QStringLiteral( "senderOverwriteAddress" ) );
    }

    /**
      Get Item object corresponding to senderOverwriteAddress()
    */
    KConfigCompilerSignallingItem *senderOverwriteAddressItem()
    {
      return mSenderOverwriteAddressItem;
    }

    /**
      Set Connect using the system proxy settings
    */
    void setUseProxy( bool v )
    {
      if (v != mUseProxy && !isUseProxyImmutable()) {
        mUseProxy = v;
        Q_EMIT useProxyChanged();
      }
    }

    Q_PROPERTY(bool useProxy READ useProxy WRITE setUseProxy NOTIFY useProxyChanged)
    Q_PROPERTY(bool isUseProxyImmutable READ isUseProxyImmutable CONSTANT)
    /**
      Get Connect using the system proxy settings
    */
    bool useProxy() const
    {
      return mUseProxy;
    }

    /**
      Is Connect using the system proxy settings Immutable
    */
    bool isUseProxyImmutable() const
    {
      return isImmutable( QStringLiteral( "useProxy" ) );
    }

    /**
      Get Item object corresponding to useProxy()
    */
    KConfigCompilerSignallingItem *useProxyItem()
    {
      return mUseProxyItem;
    }


    enum {
      signalIdChanged = 1,
      signalNameChanged = 2,
      signalIdentifierChanged = 3,
      signalHostChanged = 4,
      signalPortChanged = 5,
      signalUserNameChanged = 6,
      signalPrecommandChanged = 7,
      signalOptionsChanged = 8,
      signalRequiresAuthenticationChanged = 9,
      signalStorePasswordChanged = 10,
      signalEncryptionChanged = 11,
      signalAuthenticationTypeChanged = 12,
      signalSpecifyHostnameChanged = 13,
      signalLocalHostnameChanged = 14,
      signalSpecifySenderOverwriteAddressChanged = 15,
      signalSenderOverwriteAddressChanged = 16,
      signalUseProxyChanged = 17
    };

  Q_SIGNALS:
    void idChanged();

    void nameChanged();

    void identifierChanged();

    void hostChanged();

    void portChanged();

    void userNameChanged();

    void precommandChanged();

    void optionsChanged();

    void requiresAuthenticationChanged();

    void storePasswordChanged();

    void encryptionChanged();

    void authenticationTypeChanged();

    void specifyHostnameChanged();

    void localHostnameChanged();

    void specifySenderOverwriteAddressChanged();

    void senderOverwriteAddressChanged();

    void useProxyChanged();

  private:
    void itemChanged(quint64 signalFlag);

  protected:
    QString mParamtransportId;

    // Transport $(transportId)
    int mId;
    QString mName;
    QString mIdentifier;
    QString mHost;
    uint mPort;
    QString mUserName;
    QString mPrecommand;
    QString mOptions;
    bool mRequiresAuthentication;
    bool mStorePassword;
    int mEncryption;
    int mAuthenticationType;
    bool mSpecifyHostname;
    QString mLocalHostname;
    bool mSpecifySenderOverwriteAddress;
    QString mSenderOverwriteAddress;
    bool mUseProxy;

  private:
    KConfigCompilerSignallingItem *mIdItem;
    KConfigCompilerSignallingItem *mNameItem;
    KConfigCompilerSignallingItem *mIdentifierItem;
    KConfigCompilerSignallingItem *mHostItem;
    KConfigCompilerSignallingItem *mPortItem;
    KConfigCompilerSignallingItem *mUserNameItem;
    KConfigCompilerSignallingItem *mPrecommandItem;
    KConfigCompilerSignallingItem *mOptionsItem;
    KConfigCompilerSignallingItem *mRequiresAuthenticationItem;
    KConfigCompilerSignallingItem *mStorePasswordItem;
    KConfigCompilerSignallingItem *mEncryptionItem;
    KConfigCompilerSignallingItem *mAuthenticationTypeItem;
    KConfigCompilerSignallingItem *mSpecifyHostnameItem;
    KConfigCompilerSignallingItem *mLocalHostnameItem;
    KConfigCompilerSignallingItem *mSpecifySenderOverwriteAddressItem;
    KConfigCompilerSignallingItem *mSenderOverwriteAddressItem;
    KConfigCompilerSignallingItem *mUseProxyItem;
};

}

#endif

