types.h

Go to the documentation of this file.

#ifndef QEVERCLOUD_GENERATED_TYPES_H
#define QEVERCLOUD_GENERATED_TYPES_H

#include "../Optional.h"
#include "../export.h"
#include "EDAMErrorCode.h"
#include <QMap>
#include <QList>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QByteArray>
#include <QDateTime>
#include <QMetaType>
#include <QSharedPointer>
#include <QMetaType>

namespace qevercloud {

struct QEVERCLOUD_EXPORT PrivilegeLevel {
    enum type {
        NORMAL = 1,
        PREMIUM = 3,
        VIP = 5,
        MANAGER = 7,
        SUPPORT = 8,
        ADMIN = 9
    };
};

struct QEVERCLOUD_EXPORT QueryFormat {
    enum type {
        USER = 1,
        SEXP = 2
    };
};

struct QEVERCLOUD_EXPORT NoteSortOrder {
    enum type {
        CREATED = 1,
        UPDATED = 2,
        RELEVANCE = 3,
        UPDATE_SEQUENCE_NUMBER = 4,
        TITLE = 5
    };
};

struct QEVERCLOUD_EXPORT PremiumOrderStatus {
    enum type {
        NONE = 0,
        PENDING = 1,
        ACTIVE = 2,
        FAILED = 3,
        CANCELLATION_PENDING = 4,
        CANCELED = 5
    };
};

struct QEVERCLOUD_EXPORT SharedNotebookPrivilegeLevel {
    enum type {
        READ_NOTEBOOK = 0,
        MODIFY_NOTEBOOK_PLUS_ACTIVITY = 1,
        READ_NOTEBOOK_PLUS_ACTIVITY = 2,
        GROUP = 3,
        FULL_ACCESS = 4,
        BUSINESS_FULL_ACCESS = 5
    };
};

struct QEVERCLOUD_EXPORT SponsoredGroupRole {
    enum type {
        GROUP_MEMBER = 1,
        GROUP_ADMIN = 2,
        GROUP_OWNER = 3
    };
};

struct QEVERCLOUD_EXPORT BusinessUserRole {
    enum type {
        ADMIN = 1,
        NORMAL = 2
    };
};

struct QEVERCLOUD_EXPORT SharedNotebookInstanceRestrictions {
    enum type {
        ONLY_JOINED_OR_PREVIEW = 1,
        NO_SHARED_NOTEBOOKS = 2
    };
};

struct QEVERCLOUD_EXPORT ReminderEmailConfig {
    enum type {
        DO_NOT_SEND = 1,
        SEND_DAILY_EMAIL = 2
    };
};


typedef qint32 UserID;

typedef QString Guid;

typedef qint64 Timestamp;


struct QEVERCLOUD_EXPORT SyncState {
    Timestamp currentTime;
    Timestamp fullSyncBefore;
    qint32 updateCount;
    Optional< qint64 > uploaded;

    bool operator==(const SyncState & other) const
    {
        return (currentTime == other.currentTime)
            && (fullSyncBefore == other.fullSyncBefore)
            && (updateCount == other.updateCount)
            && uploaded.isEqual(other.uploaded)
        ;
    }

    bool operator!=(const SyncState & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SyncChunkFilter {
    Optional< bool > includeNotes;
    Optional< bool > includeNoteResources;
    Optional< bool > includeNoteAttributes;
    Optional< bool > includeNotebooks;
    Optional< bool > includeTags;
    Optional< bool > includeSearches;
    Optional< bool > includeResources;
    Optional< bool > includeLinkedNotebooks;
    Optional< bool > includeExpunged;
    Optional< bool > includeNoteApplicationDataFullMap;
    Optional< bool > includeResourceApplicationDataFullMap;
    Optional< bool > includeNoteResourceApplicationDataFullMap;
    Optional< QString > requireNoteContentClass;

    bool operator==(const SyncChunkFilter & other) const
    {
        return includeNotes.isEqual(other.includeNotes)
            && includeNoteResources.isEqual(other.includeNoteResources)
            && includeNoteAttributes.isEqual(other.includeNoteAttributes)
            && includeNotebooks.isEqual(other.includeNotebooks)
            && includeTags.isEqual(other.includeTags)
            && includeSearches.isEqual(other.includeSearches)
            && includeResources.isEqual(other.includeResources)
            && includeLinkedNotebooks.isEqual(other.includeLinkedNotebooks)
            && includeExpunged.isEqual(other.includeExpunged)
            && includeNoteApplicationDataFullMap.isEqual(other.includeNoteApplicationDataFullMap)
            && includeResourceApplicationDataFullMap.isEqual(other.includeResourceApplicationDataFullMap)
            && includeNoteResourceApplicationDataFullMap.isEqual(other.includeNoteResourceApplicationDataFullMap)
            && requireNoteContentClass.isEqual(other.requireNoteContentClass)
        ;
    }

    bool operator!=(const SyncChunkFilter & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteFilter {
    Optional< qint32 > order;
    Optional< bool > ascending;
    Optional< QString > words;
    Optional< Guid > notebookGuid;
    Optional< QList< Guid > > tagGuids;
    Optional< QString > timeZone;
    Optional< bool > inactive;
    Optional< QString > emphasized;

    bool operator==(const NoteFilter & other) const
    {
        return order.isEqual(other.order)
            && ascending.isEqual(other.ascending)
            && words.isEqual(other.words)
            && notebookGuid.isEqual(other.notebookGuid)
            && tagGuids.isEqual(other.tagGuids)
            && timeZone.isEqual(other.timeZone)
            && inactive.isEqual(other.inactive)
            && emphasized.isEqual(other.emphasized)
        ;
    }

    bool operator!=(const NoteFilter & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NotesMetadataResultSpec {
    Optional< bool > includeTitle;
    Optional< bool > includeContentLength;
    Optional< bool > includeCreated;
    Optional< bool > includeUpdated;
    Optional< bool > includeDeleted;
    Optional< bool > includeUpdateSequenceNum;
    Optional< bool > includeNotebookGuid;
    Optional< bool > includeTagGuids;
    Optional< bool > includeAttributes;
    Optional< bool > includeLargestResourceMime;
    Optional< bool > includeLargestResourceSize;

    bool operator==(const NotesMetadataResultSpec & other) const
    {
        return includeTitle.isEqual(other.includeTitle)
            && includeContentLength.isEqual(other.includeContentLength)
            && includeCreated.isEqual(other.includeCreated)
            && includeUpdated.isEqual(other.includeUpdated)
            && includeDeleted.isEqual(other.includeDeleted)
            && includeUpdateSequenceNum.isEqual(other.includeUpdateSequenceNum)
            && includeNotebookGuid.isEqual(other.includeNotebookGuid)
            && includeTagGuids.isEqual(other.includeTagGuids)
            && includeAttributes.isEqual(other.includeAttributes)
            && includeLargestResourceMime.isEqual(other.includeLargestResourceMime)
            && includeLargestResourceSize.isEqual(other.includeLargestResourceSize)
        ;
    }

    bool operator!=(const NotesMetadataResultSpec & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteCollectionCounts {
    Optional< QMap< Guid, qint32 > > notebookCounts;
    Optional< QMap< Guid, qint32 > > tagCounts;
    Optional< qint32 > trashCount;

    bool operator==(const NoteCollectionCounts & other) const
    {
        return notebookCounts.isEqual(other.notebookCounts)
            && tagCounts.isEqual(other.tagCounts)
            && trashCount.isEqual(other.trashCount)
        ;
    }

    bool operator!=(const NoteCollectionCounts & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteVersionId {
    qint32 updateSequenceNum;
    Timestamp updated;
    Timestamp saved;
    QString title;

    bool operator==(const NoteVersionId & other) const
    {
        return (updateSequenceNum == other.updateSequenceNum)
            && (updated == other.updated)
            && (saved == other.saved)
            && (title == other.title)
        ;
    }

    bool operator!=(const NoteVersionId & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT ClientUsageMetrics {
    Optional< qint32 > sessions;

    bool operator==(const ClientUsageMetrics & other) const
    {
        return sessions.isEqual(other.sessions)
        ;
    }

    bool operator!=(const ClientUsageMetrics & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT RelatedQuery {
    Optional< QString > noteGuid;
    Optional< QString > plainText;
    Optional< NoteFilter > filter;
    Optional< QString > referenceUri;

    bool operator==(const RelatedQuery & other) const
    {
        return noteGuid.isEqual(other.noteGuid)
            && plainText.isEqual(other.plainText)
            && filter.isEqual(other.filter)
            && referenceUri.isEqual(other.referenceUri)
        ;
    }

    bool operator!=(const RelatedQuery & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT RelatedResultSpec {
    Optional< qint32 > maxNotes;
    Optional< qint32 > maxNotebooks;
    Optional< qint32 > maxTags;
    Optional< bool > writableNotebooksOnly;
    Optional< bool > includeContainingNotebooks;

    bool operator==(const RelatedResultSpec & other) const
    {
        return maxNotes.isEqual(other.maxNotes)
            && maxNotebooks.isEqual(other.maxNotebooks)
            && maxTags.isEqual(other.maxTags)
            && writableNotebooksOnly.isEqual(other.writableNotebooksOnly)
            && includeContainingNotebooks.isEqual(other.includeContainingNotebooks)
        ;
    }

    bool operator!=(const RelatedResultSpec & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Data {
    Optional< QByteArray > bodyHash;
    Optional< qint32 > size;
    Optional< QByteArray > body;

    bool operator==(const Data & other) const
    {
        return bodyHash.isEqual(other.bodyHash)
            && size.isEqual(other.size)
            && body.isEqual(other.body)
        ;
    }

    bool operator!=(const Data & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT UserAttributes {
    Optional< QString > defaultLocationName;
    Optional< double > defaultLatitude;
    Optional< double > defaultLongitude;
    Optional< bool > preactivation;
    Optional< QStringList > viewedPromotions;
    Optional< QString > incomingEmailAddress;
    Optional< QStringList > recentMailedAddresses;
    Optional< QString > comments;
    Optional< Timestamp > dateAgreedToTermsOfService;
    Optional< qint32 > maxReferrals;
    Optional< qint32 > referralCount;
    Optional< QString > refererCode;
    Optional< Timestamp > sentEmailDate;
    Optional< qint32 > sentEmailCount;
    Optional< qint32 > dailyEmailLimit;
    Optional< Timestamp > emailOptOutDate;
    Optional< Timestamp > partnerEmailOptInDate;
    Optional< QString > preferredLanguage;
    Optional< QString > preferredCountry;
    Optional< bool > clipFullPage;
    Optional< QString > twitterUserName;
    Optional< QString > twitterId;
    Optional< QString > groupName;
    Optional< QString > recognitionLanguage;
    Optional< QString > referralProof;
    Optional< bool > educationalDiscount;
    Optional< QString > businessAddress;
    Optional< bool > hideSponsorBilling;
    Optional< bool > taxExempt;
    Optional< bool > useEmailAutoFiling;
    Optional< ReminderEmailConfig::type > reminderEmailConfig;

    bool operator==(const UserAttributes & other) const
    {
        return defaultLocationName.isEqual(other.defaultLocationName)
            && defaultLatitude.isEqual(other.defaultLatitude)
            && defaultLongitude.isEqual(other.defaultLongitude)
            && preactivation.isEqual(other.preactivation)
            && viewedPromotions.isEqual(other.viewedPromotions)
            && incomingEmailAddress.isEqual(other.incomingEmailAddress)
            && recentMailedAddresses.isEqual(other.recentMailedAddresses)
            && comments.isEqual(other.comments)
            && dateAgreedToTermsOfService.isEqual(other.dateAgreedToTermsOfService)
            && maxReferrals.isEqual(other.maxReferrals)
            && referralCount.isEqual(other.referralCount)
            && refererCode.isEqual(other.refererCode)
            && sentEmailDate.isEqual(other.sentEmailDate)
            && sentEmailCount.isEqual(other.sentEmailCount)
            && dailyEmailLimit.isEqual(other.dailyEmailLimit)
            && emailOptOutDate.isEqual(other.emailOptOutDate)
            && partnerEmailOptInDate.isEqual(other.partnerEmailOptInDate)
            && preferredLanguage.isEqual(other.preferredLanguage)
            && preferredCountry.isEqual(other.preferredCountry)
            && clipFullPage.isEqual(other.clipFullPage)
            && twitterUserName.isEqual(other.twitterUserName)
            && twitterId.isEqual(other.twitterId)
            && groupName.isEqual(other.groupName)
            && recognitionLanguage.isEqual(other.recognitionLanguage)
            && referralProof.isEqual(other.referralProof)
            && educationalDiscount.isEqual(other.educationalDiscount)
            && businessAddress.isEqual(other.businessAddress)
            && hideSponsorBilling.isEqual(other.hideSponsorBilling)
            && taxExempt.isEqual(other.taxExempt)
            && useEmailAutoFiling.isEqual(other.useEmailAutoFiling)
            && reminderEmailConfig.isEqual(other.reminderEmailConfig)
        ;
    }

    bool operator!=(const UserAttributes & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Accounting {
    Optional< qint64 > uploadLimit;
    Optional< Timestamp > uploadLimitEnd;
    Optional< qint64 > uploadLimitNextMonth;
    Optional< PremiumOrderStatus::type > premiumServiceStatus;
    Optional< QString > premiumOrderNumber;
    Optional< QString > premiumCommerceService;
    Optional< Timestamp > premiumServiceStart;
    Optional< QString > premiumServiceSKU;
    Optional< Timestamp > lastSuccessfulCharge;
    Optional< Timestamp > lastFailedCharge;
    Optional< QString > lastFailedChargeReason;
    Optional< Timestamp > nextPaymentDue;
    Optional< Timestamp > premiumLockUntil;
    Optional< Timestamp > updated;
    Optional< QString > premiumSubscriptionNumber;
    Optional< Timestamp > lastRequestedCharge;
    Optional< QString > currency;
    Optional< qint32 > unitPrice;
    Optional< qint32 > businessId;
    Optional< QString > businessName;
    Optional< BusinessUserRole::type > businessRole;
    Optional< qint32 > unitDiscount;
    Optional< Timestamp > nextChargeDate;

    bool operator==(const Accounting & other) const
    {
        return uploadLimit.isEqual(other.uploadLimit)
            && uploadLimitEnd.isEqual(other.uploadLimitEnd)
            && uploadLimitNextMonth.isEqual(other.uploadLimitNextMonth)
            && premiumServiceStatus.isEqual(other.premiumServiceStatus)
            && premiumOrderNumber.isEqual(other.premiumOrderNumber)
            && premiumCommerceService.isEqual(other.premiumCommerceService)
            && premiumServiceStart.isEqual(other.premiumServiceStart)
            && premiumServiceSKU.isEqual(other.premiumServiceSKU)
            && lastSuccessfulCharge.isEqual(other.lastSuccessfulCharge)
            && lastFailedCharge.isEqual(other.lastFailedCharge)
            && lastFailedChargeReason.isEqual(other.lastFailedChargeReason)
            && nextPaymentDue.isEqual(other.nextPaymentDue)
            && premiumLockUntil.isEqual(other.premiumLockUntil)
            && updated.isEqual(other.updated)
            && premiumSubscriptionNumber.isEqual(other.premiumSubscriptionNumber)
            && lastRequestedCharge.isEqual(other.lastRequestedCharge)
            && currency.isEqual(other.currency)
            && unitPrice.isEqual(other.unitPrice)
            && businessId.isEqual(other.businessId)
            && businessName.isEqual(other.businessName)
            && businessRole.isEqual(other.businessRole)
            && unitDiscount.isEqual(other.unitDiscount)
            && nextChargeDate.isEqual(other.nextChargeDate)
        ;
    }

    bool operator!=(const Accounting & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT BusinessUserInfo {
    Optional< qint32 > businessId;
    Optional< QString > businessName;
    Optional< BusinessUserRole::type > role;
    Optional< QString > email;

    bool operator==(const BusinessUserInfo & other) const
    {
        return businessId.isEqual(other.businessId)
            && businessName.isEqual(other.businessName)
            && role.isEqual(other.role)
            && email.isEqual(other.email)
        ;
    }

    bool operator!=(const BusinessUserInfo & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT PremiumInfo {
    Timestamp currentTime;
    bool premium;
    bool premiumRecurring;
    Optional< Timestamp > premiumExpirationDate;
    bool premiumExtendable;
    bool premiumPending;
    bool premiumCancellationPending;
    bool canPurchaseUploadAllowance;
    Optional< QString > sponsoredGroupName;
    Optional< SponsoredGroupRole::type > sponsoredGroupRole;
    Optional< bool > premiumUpgradable;

    bool operator==(const PremiumInfo & other) const
    {
        return (currentTime == other.currentTime)
            && (premium == other.premium)
            && (premiumRecurring == other.premiumRecurring)
            && premiumExpirationDate.isEqual(other.premiumExpirationDate)
            && (premiumExtendable == other.premiumExtendable)
            && (premiumPending == other.premiumPending)
            && (premiumCancellationPending == other.premiumCancellationPending)
            && (canPurchaseUploadAllowance == other.canPurchaseUploadAllowance)
            && sponsoredGroupName.isEqual(other.sponsoredGroupName)
            && sponsoredGroupRole.isEqual(other.sponsoredGroupRole)
            && premiumUpgradable.isEqual(other.premiumUpgradable)
        ;
    }

    bool operator!=(const PremiumInfo & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT User {
    Optional< UserID > id;
    Optional< QString > username;
    Optional< QString > email;
    Optional< QString > name;
    Optional< QString > timezone;
    Optional< PrivilegeLevel::type > privilege;
    Optional< Timestamp > created;
    Optional< Timestamp > updated;
    Optional< Timestamp > deleted;
    Optional< bool > active;
    Optional< QString > shardId;
    Optional< UserAttributes > attributes;
    Optional< Accounting > accounting;
    Optional< PremiumInfo > premiumInfo;
    Optional< BusinessUserInfo > businessUserInfo;

    bool operator==(const User & other) const
    {
        return id.isEqual(other.id)
            && username.isEqual(other.username)
            && email.isEqual(other.email)
            && name.isEqual(other.name)
            && timezone.isEqual(other.timezone)
            && privilege.isEqual(other.privilege)
            && created.isEqual(other.created)
            && updated.isEqual(other.updated)
            && deleted.isEqual(other.deleted)
            && active.isEqual(other.active)
            && shardId.isEqual(other.shardId)
            && attributes.isEqual(other.attributes)
            && accounting.isEqual(other.accounting)
            && premiumInfo.isEqual(other.premiumInfo)
            && businessUserInfo.isEqual(other.businessUserInfo)
        ;
    }

    bool operator!=(const User & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Tag {
    Optional< Guid > guid;
    Optional< QString > name;
    Optional< Guid > parentGuid;
    Optional< qint32 > updateSequenceNum;

    bool operator==(const Tag & other) const
    {
        return guid.isEqual(other.guid)
            && name.isEqual(other.name)
            && parentGuid.isEqual(other.parentGuid)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
        ;
    }

    bool operator!=(const Tag & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT LazyMap {
    Optional< QSet< QString > > keysOnly;
    Optional< QMap< QString, QString > > fullMap;

    bool operator==(const LazyMap & other) const
    {
        return keysOnly.isEqual(other.keysOnly)
            && fullMap.isEqual(other.fullMap)
        ;
    }

    bool operator!=(const LazyMap & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT ResourceAttributes {
    Optional< QString > sourceURL;
    Optional< Timestamp > timestamp;
    Optional< double > latitude;
    Optional< double > longitude;
    Optional< double > altitude;
    Optional< QString > cameraMake;
    Optional< QString > cameraModel;
    Optional< bool > clientWillIndex;
    Optional< QString > recoType;
    Optional< QString > fileName;
    Optional< bool > attachment;
    Optional< LazyMap > applicationData;

    bool operator==(const ResourceAttributes & other) const
    {
        return sourceURL.isEqual(other.sourceURL)
            && timestamp.isEqual(other.timestamp)
            && latitude.isEqual(other.latitude)
            && longitude.isEqual(other.longitude)
            && altitude.isEqual(other.altitude)
            && cameraMake.isEqual(other.cameraMake)
            && cameraModel.isEqual(other.cameraModel)
            && clientWillIndex.isEqual(other.clientWillIndex)
            && recoType.isEqual(other.recoType)
            && fileName.isEqual(other.fileName)
            && attachment.isEqual(other.attachment)
            && applicationData.isEqual(other.applicationData)
        ;
    }

    bool operator!=(const ResourceAttributes & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Resource {
    Optional< Guid > guid;
    Optional< Guid > noteGuid;
    Optional< Data > data;
    Optional< QString > mime;
    Optional< qint16 > width;
    Optional< qint16 > height;
    Optional< qint16 > duration;
    Optional< bool > active;
    Optional< Data > recognition;
    Optional< ResourceAttributes > attributes;
    Optional< qint32 > updateSequenceNum;
    Optional< Data > alternateData;

    bool operator==(const Resource & other) const
    {
        return guid.isEqual(other.guid)
            && noteGuid.isEqual(other.noteGuid)
            && data.isEqual(other.data)
            && mime.isEqual(other.mime)
            && width.isEqual(other.width)
            && height.isEqual(other.height)
            && duration.isEqual(other.duration)
            && active.isEqual(other.active)
            && recognition.isEqual(other.recognition)
            && attributes.isEqual(other.attributes)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && alternateData.isEqual(other.alternateData)
        ;
    }

    bool operator!=(const Resource & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteAttributes {
    Optional< Timestamp > subjectDate;
    Optional< double > latitude;
    Optional< double > longitude;
    Optional< double > altitude;
    Optional< QString > author;
    Optional< QString > source;
    Optional< QString > sourceURL;
    Optional< QString > sourceApplication;
    Optional< Timestamp > shareDate;
    Optional< qint64 > reminderOrder;
    Optional< Timestamp > reminderDoneTime;
    Optional< Timestamp > reminderTime;
    Optional< QString > placeName;
    Optional< QString > contentClass;
    Optional< LazyMap > applicationData;
    Optional< QString > lastEditedBy;
    Optional< QMap< QString, QString > > classifications;
    Optional< UserID > creatorId;
    Optional< UserID > lastEditorId;

    bool operator==(const NoteAttributes & other) const
    {
        return subjectDate.isEqual(other.subjectDate)
            && latitude.isEqual(other.latitude)
            && longitude.isEqual(other.longitude)
            && altitude.isEqual(other.altitude)
            && author.isEqual(other.author)
            && source.isEqual(other.source)
            && sourceURL.isEqual(other.sourceURL)
            && sourceApplication.isEqual(other.sourceApplication)
            && shareDate.isEqual(other.shareDate)
            && reminderOrder.isEqual(other.reminderOrder)
            && reminderDoneTime.isEqual(other.reminderDoneTime)
            && reminderTime.isEqual(other.reminderTime)
            && placeName.isEqual(other.placeName)
            && contentClass.isEqual(other.contentClass)
            && applicationData.isEqual(other.applicationData)
            && lastEditedBy.isEqual(other.lastEditedBy)
            && classifications.isEqual(other.classifications)
            && creatorId.isEqual(other.creatorId)
            && lastEditorId.isEqual(other.lastEditorId)
        ;
    }

    bool operator!=(const NoteAttributes & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Note {
    Optional< Guid > guid;
    Optional< QString > title;
    Optional< QString > content;
    Optional< QByteArray > contentHash;
    Optional< qint32 > contentLength;
    Optional< Timestamp > created;
    Optional< Timestamp > updated;
    Optional< Timestamp > deleted;
    Optional< bool > active;
    Optional< qint32 > updateSequenceNum;
    Optional< QString > notebookGuid;
    Optional< QList< Guid > > tagGuids;
    Optional< QList< Resource > > resources;
    Optional< NoteAttributes > attributes;
    Optional< QStringList > tagNames;

    bool operator==(const Note & other) const
    {
        return guid.isEqual(other.guid)
            && title.isEqual(other.title)
            && content.isEqual(other.content)
            && contentHash.isEqual(other.contentHash)
            && contentLength.isEqual(other.contentLength)
            && created.isEqual(other.created)
            && updated.isEqual(other.updated)
            && deleted.isEqual(other.deleted)
            && active.isEqual(other.active)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && notebookGuid.isEqual(other.notebookGuid)
            && tagGuids.isEqual(other.tagGuids)
            && resources.isEqual(other.resources)
            && attributes.isEqual(other.attributes)
            && tagNames.isEqual(other.tagNames)
        ;
    }

    bool operator!=(const Note & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Publishing {
    Optional< QString > uri;
    Optional< NoteSortOrder::type > order;
    Optional< bool > ascending;
    Optional< QString > publicDescription;

    bool operator==(const Publishing & other) const
    {
        return uri.isEqual(other.uri)
            && order.isEqual(other.order)
            && ascending.isEqual(other.ascending)
            && publicDescription.isEqual(other.publicDescription)
        ;
    }

    bool operator!=(const Publishing & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT BusinessNotebook {
    Optional< QString > notebookDescription;
    Optional< SharedNotebookPrivilegeLevel::type > privilege;
    Optional< bool > recommended;

    bool operator==(const BusinessNotebook & other) const
    {
        return notebookDescription.isEqual(other.notebookDescription)
            && privilege.isEqual(other.privilege)
            && recommended.isEqual(other.recommended)
        ;
    }

    bool operator!=(const BusinessNotebook & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SavedSearchScope {
    Optional< bool > includeAccount;
    Optional< bool > includePersonalLinkedNotebooks;
    Optional< bool > includeBusinessLinkedNotebooks;

    bool operator==(const SavedSearchScope & other) const
    {
        return includeAccount.isEqual(other.includeAccount)
            && includePersonalLinkedNotebooks.isEqual(other.includePersonalLinkedNotebooks)
            && includeBusinessLinkedNotebooks.isEqual(other.includeBusinessLinkedNotebooks)
        ;
    }

    bool operator!=(const SavedSearchScope & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SavedSearch {
    Optional< Guid > guid;
    Optional< QString > name;
    Optional< QString > query;
    Optional< QueryFormat::type > format;
    Optional< qint32 > updateSequenceNum;
    Optional< SavedSearchScope > scope;

    bool operator==(const SavedSearch & other) const
    {
        return guid.isEqual(other.guid)
            && name.isEqual(other.name)
            && query.isEqual(other.query)
            && format.isEqual(other.format)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && scope.isEqual(other.scope)
        ;
    }

    bool operator!=(const SavedSearch & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SharedNotebookRecipientSettings {
    Optional< bool > reminderNotifyEmail;
    Optional< bool > reminderNotifyInApp;

    bool operator==(const SharedNotebookRecipientSettings & other) const
    {
        return reminderNotifyEmail.isEqual(other.reminderNotifyEmail)
            && reminderNotifyInApp.isEqual(other.reminderNotifyInApp)
        ;
    }

    bool operator!=(const SharedNotebookRecipientSettings & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SharedNotebook {
    Optional< qint64 > id;
    Optional< qint32 > userId;
    Optional< QString > notebookGuid;
    Optional< QString > email;
    Optional< bool > notebookModifiable;
    Optional< bool > requireLogin;
    Optional< Timestamp > serviceCreated;
    Optional< Timestamp > serviceUpdated;
    Optional< QString > shareKey;
    Optional< QString > username;
    Optional< SharedNotebookPrivilegeLevel::type > privilege;
    Optional< bool > allowPreview;
    Optional< SharedNotebookRecipientSettings > recipientSettings;

    bool operator==(const SharedNotebook & other) const
    {
        return id.isEqual(other.id)
            && userId.isEqual(other.userId)
            && notebookGuid.isEqual(other.notebookGuid)
            && email.isEqual(other.email)
            && notebookModifiable.isEqual(other.notebookModifiable)
            && requireLogin.isEqual(other.requireLogin)
            && serviceCreated.isEqual(other.serviceCreated)
            && serviceUpdated.isEqual(other.serviceUpdated)
            && shareKey.isEqual(other.shareKey)
            && username.isEqual(other.username)
            && privilege.isEqual(other.privilege)
            && allowPreview.isEqual(other.allowPreview)
            && recipientSettings.isEqual(other.recipientSettings)
        ;
    }

    bool operator!=(const SharedNotebook & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NotebookRestrictions {
    Optional< bool > noReadNotes;
    Optional< bool > noCreateNotes;
    Optional< bool > noUpdateNotes;
    Optional< bool > noExpungeNotes;
    Optional< bool > noShareNotes;
    Optional< bool > noEmailNotes;
    Optional< bool > noSendMessageToRecipients;
    Optional< bool > noUpdateNotebook;
    Optional< bool > noExpungeNotebook;
    Optional< bool > noSetDefaultNotebook;
    Optional< bool > noSetNotebookStack;
    Optional< bool > noPublishToPublic;
    Optional< bool > noPublishToBusinessLibrary;
    Optional< bool > noCreateTags;
    Optional< bool > noUpdateTags;
    Optional< bool > noExpungeTags;
    Optional< bool > noSetParentTag;
    Optional< bool > noCreateSharedNotebooks;
    Optional< SharedNotebookInstanceRestrictions::type > updateWhichSharedNotebookRestrictions;
    Optional< SharedNotebookInstanceRestrictions::type > expungeWhichSharedNotebookRestrictions;

    bool operator==(const NotebookRestrictions & other) const
    {
        return noReadNotes.isEqual(other.noReadNotes)
            && noCreateNotes.isEqual(other.noCreateNotes)
            && noUpdateNotes.isEqual(other.noUpdateNotes)
            && noExpungeNotes.isEqual(other.noExpungeNotes)
            && noShareNotes.isEqual(other.noShareNotes)
            && noEmailNotes.isEqual(other.noEmailNotes)
            && noSendMessageToRecipients.isEqual(other.noSendMessageToRecipients)
            && noUpdateNotebook.isEqual(other.noUpdateNotebook)
            && noExpungeNotebook.isEqual(other.noExpungeNotebook)
            && noSetDefaultNotebook.isEqual(other.noSetDefaultNotebook)
            && noSetNotebookStack.isEqual(other.noSetNotebookStack)
            && noPublishToPublic.isEqual(other.noPublishToPublic)
            && noPublishToBusinessLibrary.isEqual(other.noPublishToBusinessLibrary)
            && noCreateTags.isEqual(other.noCreateTags)
            && noUpdateTags.isEqual(other.noUpdateTags)
            && noExpungeTags.isEqual(other.noExpungeTags)
            && noSetParentTag.isEqual(other.noSetParentTag)
            && noCreateSharedNotebooks.isEqual(other.noCreateSharedNotebooks)
            && updateWhichSharedNotebookRestrictions.isEqual(other.updateWhichSharedNotebookRestrictions)
            && expungeWhichSharedNotebookRestrictions.isEqual(other.expungeWhichSharedNotebookRestrictions)
        ;
    }

    bool operator!=(const NotebookRestrictions & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT Notebook {
    Optional< Guid > guid;
    Optional< QString > name;
    Optional< qint32 > updateSequenceNum;
    Optional< bool > defaultNotebook;
    Optional< Timestamp > serviceCreated;
    Optional< Timestamp > serviceUpdated;
    Optional< Publishing > publishing;
    Optional< bool > published;
    Optional< QString > stack;
    Optional< QList< qint64 > > sharedNotebookIds;
    Optional< QList< SharedNotebook > > sharedNotebooks;
    Optional< BusinessNotebook > businessNotebook;
    Optional< User > contact;
    Optional< NotebookRestrictions > restrictions;

    bool operator==(const Notebook & other) const
    {
        return guid.isEqual(other.guid)
            && name.isEqual(other.name)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && defaultNotebook.isEqual(other.defaultNotebook)
            && serviceCreated.isEqual(other.serviceCreated)
            && serviceUpdated.isEqual(other.serviceUpdated)
            && publishing.isEqual(other.publishing)
            && published.isEqual(other.published)
            && stack.isEqual(other.stack)
            && sharedNotebookIds.isEqual(other.sharedNotebookIds)
            && sharedNotebooks.isEqual(other.sharedNotebooks)
            && businessNotebook.isEqual(other.businessNotebook)
            && contact.isEqual(other.contact)
            && restrictions.isEqual(other.restrictions)
        ;
    }

    bool operator!=(const Notebook & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT LinkedNotebook {
    Optional< QString > shareName;
    Optional< QString > username;
    Optional< QString > shardId;
    Optional< QString > shareKey;
    Optional< QString > uri;
    Optional< Guid > guid;
    Optional< qint32 > updateSequenceNum;
    Optional< QString > noteStoreUrl;
    Optional< QString > webApiUrlPrefix;
    Optional< QString > stack;
    Optional< qint32 > businessId;

    bool operator==(const LinkedNotebook & other) const
    {
        return shareName.isEqual(other.shareName)
            && username.isEqual(other.username)
            && shardId.isEqual(other.shardId)
            && shareKey.isEqual(other.shareKey)
            && uri.isEqual(other.uri)
            && guid.isEqual(other.guid)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && noteStoreUrl.isEqual(other.noteStoreUrl)
            && webApiUrlPrefix.isEqual(other.webApiUrlPrefix)
            && stack.isEqual(other.stack)
            && businessId.isEqual(other.businessId)
        ;
    }

    bool operator!=(const LinkedNotebook & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NotebookDescriptor {
    Optional< Guid > guid;
    Optional< QString > notebookDisplayName;
    Optional< QString > contactName;
    Optional< bool > hasSharedNotebook;
    Optional< qint32 > joinedUserCount;

    bool operator==(const NotebookDescriptor & other) const
    {
        return guid.isEqual(other.guid)
            && notebookDisplayName.isEqual(other.notebookDisplayName)
            && contactName.isEqual(other.contactName)
            && hasSharedNotebook.isEqual(other.hasSharedNotebook)
            && joinedUserCount.isEqual(other.joinedUserCount)
        ;
    }

    bool operator!=(const NotebookDescriptor & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT PublicUserInfo {
    UserID userId;
    QString shardId;
    Optional< PrivilegeLevel::type > privilege;
    Optional< QString > username;
    Optional< QString > noteStoreUrl;
    Optional< QString > webApiUrlPrefix;

    bool operator==(const PublicUserInfo & other) const
    {
        return (userId == other.userId)
            && (shardId == other.shardId)
            && privilege.isEqual(other.privilege)
            && username.isEqual(other.username)
            && noteStoreUrl.isEqual(other.noteStoreUrl)
            && webApiUrlPrefix.isEqual(other.webApiUrlPrefix)
        ;
    }

    bool operator!=(const PublicUserInfo & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT AuthenticationResult {
    Timestamp currentTime;
    QString authenticationToken;
    Timestamp expiration;
    Optional< User > user;
    Optional< PublicUserInfo > publicUserInfo;
    Optional< QString > noteStoreUrl;
    Optional< QString > webApiUrlPrefix;
    Optional< bool > secondFactorRequired;
    Optional< QString > secondFactorDeliveryHint;

    bool operator==(const AuthenticationResult & other) const
    {
        return (currentTime == other.currentTime)
            && (authenticationToken == other.authenticationToken)
            && (expiration == other.expiration)
            && user.isEqual(other.user)
            && publicUserInfo.isEqual(other.publicUserInfo)
            && noteStoreUrl.isEqual(other.noteStoreUrl)
            && webApiUrlPrefix.isEqual(other.webApiUrlPrefix)
            && secondFactorRequired.isEqual(other.secondFactorRequired)
            && secondFactorDeliveryHint.isEqual(other.secondFactorDeliveryHint)
        ;
    }

    bool operator!=(const AuthenticationResult & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT BootstrapSettings {
    QString serviceHost;
    QString marketingUrl;
    QString supportUrl;
    QString accountEmailDomain;
    Optional< bool > enableFacebookSharing;
    Optional< bool > enableGiftSubscriptions;
    Optional< bool > enableSupportTickets;
    Optional< bool > enableSharedNotebooks;
    Optional< bool > enableSingleNoteSharing;
    Optional< bool > enableSponsoredAccounts;
    Optional< bool > enableTwitterSharing;
    Optional< bool > enableLinkedInSharing;
    Optional< bool > enablePublicNotebooks;

    bool operator==(const BootstrapSettings & other) const
    {
        return (serviceHost == other.serviceHost)
            && (marketingUrl == other.marketingUrl)
            && (supportUrl == other.supportUrl)
            && (accountEmailDomain == other.accountEmailDomain)
            && enableFacebookSharing.isEqual(other.enableFacebookSharing)
            && enableGiftSubscriptions.isEqual(other.enableGiftSubscriptions)
            && enableSupportTickets.isEqual(other.enableSupportTickets)
            && enableSharedNotebooks.isEqual(other.enableSharedNotebooks)
            && enableSingleNoteSharing.isEqual(other.enableSingleNoteSharing)
            && enableSponsoredAccounts.isEqual(other.enableSponsoredAccounts)
            && enableTwitterSharing.isEqual(other.enableTwitterSharing)
            && enableLinkedInSharing.isEqual(other.enableLinkedInSharing)
            && enablePublicNotebooks.isEqual(other.enablePublicNotebooks)
        ;
    }

    bool operator!=(const BootstrapSettings & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT BootstrapProfile {
    QString name;
    BootstrapSettings settings;

    bool operator==(const BootstrapProfile & other) const
    {
        return (name == other.name)
            && (settings == other.settings)
        ;
    }

    bool operator!=(const BootstrapProfile & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT BootstrapInfo {
    QList< BootstrapProfile > profiles;

    bool operator==(const BootstrapInfo & other) const
    {
        return (profiles == other.profiles)
        ;
    }

    bool operator!=(const BootstrapInfo & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT SyncChunk {
    Timestamp currentTime;
    Optional< qint32 > chunkHighUSN;
    qint32 updateCount;
    Optional< QList< Note > > notes;
    Optional< QList< Notebook > > notebooks;
    Optional< QList< Tag > > tags;
    Optional< QList< SavedSearch > > searches;
    Optional< QList< Resource > > resources;
    Optional< QList< Guid > > expungedNotes;
    Optional< QList< Guid > > expungedNotebooks;
    Optional< QList< Guid > > expungedTags;
    Optional< QList< Guid > > expungedSearches;
    Optional< QList< LinkedNotebook > > linkedNotebooks;
    Optional< QList< Guid > > expungedLinkedNotebooks;

    bool operator==(const SyncChunk & other) const
    {
        return (currentTime == other.currentTime)
            && chunkHighUSN.isEqual(other.chunkHighUSN)
            && (updateCount == other.updateCount)
            && notes.isEqual(other.notes)
            && notebooks.isEqual(other.notebooks)
            && tags.isEqual(other.tags)
            && searches.isEqual(other.searches)
            && resources.isEqual(other.resources)
            && expungedNotes.isEqual(other.expungedNotes)
            && expungedNotebooks.isEqual(other.expungedNotebooks)
            && expungedTags.isEqual(other.expungedTags)
            && expungedSearches.isEqual(other.expungedSearches)
            && linkedNotebooks.isEqual(other.linkedNotebooks)
            && expungedLinkedNotebooks.isEqual(other.expungedLinkedNotebooks)
        ;
    }

    bool operator!=(const SyncChunk & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteList {
    qint32 startIndex;
    qint32 totalNotes;
    QList< Note > notes;
    Optional< QStringList > stoppedWords;
    Optional< QStringList > searchedWords;
    Optional< qint32 > updateCount;

    bool operator==(const NoteList & other) const
    {
        return (startIndex == other.startIndex)
            && (totalNotes == other.totalNotes)
            && (notes == other.notes)
            && stoppedWords.isEqual(other.stoppedWords)
            && searchedWords.isEqual(other.searchedWords)
            && updateCount.isEqual(other.updateCount)
        ;
    }

    bool operator!=(const NoteList & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteMetadata {
    Guid guid;
    Optional< QString > title;
    Optional< qint32 > contentLength;
    Optional< Timestamp > created;
    Optional< Timestamp > updated;
    Optional< Timestamp > deleted;
    Optional< qint32 > updateSequenceNum;
    Optional< QString > notebookGuid;
    Optional< QList< Guid > > tagGuids;
    Optional< NoteAttributes > attributes;
    Optional< QString > largestResourceMime;
    Optional< qint32 > largestResourceSize;

    bool operator==(const NoteMetadata & other) const
    {
        return (guid == other.guid)
            && title.isEqual(other.title)
            && contentLength.isEqual(other.contentLength)
            && created.isEqual(other.created)
            && updated.isEqual(other.updated)
            && deleted.isEqual(other.deleted)
            && updateSequenceNum.isEqual(other.updateSequenceNum)
            && notebookGuid.isEqual(other.notebookGuid)
            && tagGuids.isEqual(other.tagGuids)
            && attributes.isEqual(other.attributes)
            && largestResourceMime.isEqual(other.largestResourceMime)
            && largestResourceSize.isEqual(other.largestResourceSize)
        ;
    }

    bool operator!=(const NoteMetadata & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NotesMetadataList {
    qint32 startIndex;
    qint32 totalNotes;
    QList< NoteMetadata > notes;
    Optional< QStringList > stoppedWords;
    Optional< QStringList > searchedWords;
    Optional< qint32 > updateCount;

    bool operator==(const NotesMetadataList & other) const
    {
        return (startIndex == other.startIndex)
            && (totalNotes == other.totalNotes)
            && (notes == other.notes)
            && stoppedWords.isEqual(other.stoppedWords)
            && searchedWords.isEqual(other.searchedWords)
            && updateCount.isEqual(other.updateCount)
        ;
    }

    bool operator!=(const NotesMetadataList & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT NoteEmailParameters {
    Optional< QString > guid;
    Optional< Note > note;
    Optional< QStringList > toAddresses;
    Optional< QStringList > ccAddresses;
    Optional< QString > subject;
    Optional< QString > message;

    bool operator==(const NoteEmailParameters & other) const
    {
        return guid.isEqual(other.guid)
            && note.isEqual(other.note)
            && toAddresses.isEqual(other.toAddresses)
            && ccAddresses.isEqual(other.ccAddresses)
            && subject.isEqual(other.subject)
            && message.isEqual(other.message)
        ;
    }

    bool operator!=(const NoteEmailParameters & other) const
    {
        return !(*this == other);
    }

};

struct QEVERCLOUD_EXPORT RelatedResult {
    Optional< QList< Note > > notes;
    Optional< QList< Notebook > > notebooks;
    Optional< QList< Tag > > tags;
    Optional< QList< NotebookDescriptor > > containingNotebooks;

    bool operator==(const RelatedResult & other) const
    {
        return notes.isEqual(other.notes)
            && notebooks.isEqual(other.notebooks)
            && tags.isEqual(other.tags)
            && containingNotebooks.isEqual(other.containingNotebooks)
        ;
    }

    bool operator!=(const RelatedResult & other) const
    {
        return !(*this == other);
    }

};


class QEVERCLOUD_EXPORT EDAMUserException: public EvernoteException
{
public:
    EDAMErrorCode::type errorCode;
    Optional< QString > parameter;

    EDAMUserException() {}
    ~EDAMUserException() throw() {}
    const char * what() const throw() Q_DECL_OVERRIDE;
    virtual QSharedPointer<EverCloudExceptionData> exceptionData() const Q_DECL_OVERRIDE;
};

class QEVERCLOUD_EXPORT EDAMSystemException: public EvernoteException
{
public:
    EDAMErrorCode::type errorCode;
    Optional< QString > message;
    Optional< qint32 > rateLimitDuration;

    EDAMSystemException() {}
    ~EDAMSystemException() throw() {}
    const char * what() const throw() Q_DECL_OVERRIDE;
    virtual QSharedPointer<EverCloudExceptionData> exceptionData() const Q_DECL_OVERRIDE;
};

class QEVERCLOUD_EXPORT EDAMNotFoundException: public EvernoteException
{
public:
    Optional< QString > identifier;
    Optional< QString > key;

    EDAMNotFoundException() {}
    ~EDAMNotFoundException() throw() {}
    const char * what() const throw() Q_DECL_OVERRIDE;
    virtual QSharedPointer<EverCloudExceptionData> exceptionData() const Q_DECL_OVERRIDE;
};


} // namespace qevercloud

Q_DECLARE_METATYPE(qevercloud::SyncState)
Q_DECLARE_METATYPE(qevercloud::SyncChunkFilter)
Q_DECLARE_METATYPE(qevercloud::NoteFilter)
Q_DECLARE_METATYPE(qevercloud::NotesMetadataResultSpec)
Q_DECLARE_METATYPE(qevercloud::NoteCollectionCounts)
Q_DECLARE_METATYPE(qevercloud::NoteVersionId)
Q_DECLARE_METATYPE(qevercloud::ClientUsageMetrics)
Q_DECLARE_METATYPE(qevercloud::RelatedQuery)
Q_DECLARE_METATYPE(qevercloud::RelatedResultSpec)
Q_DECLARE_METATYPE(qevercloud::Data)
Q_DECLARE_METATYPE(qevercloud::UserAttributes)
Q_DECLARE_METATYPE(qevercloud::Accounting)
Q_DECLARE_METATYPE(qevercloud::BusinessUserInfo)
Q_DECLARE_METATYPE(qevercloud::PremiumInfo)
Q_DECLARE_METATYPE(qevercloud::User)
Q_DECLARE_METATYPE(qevercloud::Tag)
Q_DECLARE_METATYPE(qevercloud::LazyMap)
Q_DECLARE_METATYPE(qevercloud::ResourceAttributes)
Q_DECLARE_METATYPE(qevercloud::Resource)
Q_DECLARE_METATYPE(qevercloud::NoteAttributes)
Q_DECLARE_METATYPE(qevercloud::Note)
Q_DECLARE_METATYPE(qevercloud::Publishing)
Q_DECLARE_METATYPE(qevercloud::BusinessNotebook)
Q_DECLARE_METATYPE(qevercloud::SavedSearchScope)
Q_DECLARE_METATYPE(qevercloud::SavedSearch)
Q_DECLARE_METATYPE(qevercloud::SharedNotebookRecipientSettings)
Q_DECLARE_METATYPE(qevercloud::SharedNotebook)
Q_DECLARE_METATYPE(qevercloud::NotebookRestrictions)
Q_DECLARE_METATYPE(qevercloud::Notebook)
Q_DECLARE_METATYPE(qevercloud::LinkedNotebook)
Q_DECLARE_METATYPE(qevercloud::NotebookDescriptor)
Q_DECLARE_METATYPE(qevercloud::PublicUserInfo)
Q_DECLARE_METATYPE(qevercloud::AuthenticationResult)
Q_DECLARE_METATYPE(qevercloud::BootstrapSettings)
Q_DECLARE_METATYPE(qevercloud::BootstrapProfile)
Q_DECLARE_METATYPE(qevercloud::BootstrapInfo)
Q_DECLARE_METATYPE(qevercloud::SyncChunk)
Q_DECLARE_METATYPE(qevercloud::NoteList)
Q_DECLARE_METATYPE(qevercloud::NoteMetadata)
Q_DECLARE_METATYPE(qevercloud::NotesMetadataList)
Q_DECLARE_METATYPE(qevercloud::NoteEmailParameters)
Q_DECLARE_METATYPE(qevercloud::RelatedResult)

#endif // QEVERCLOUD_GENERATED_TYPES_H