Thrift module: NoteStore

Module	Services	Data types	Constants
NoteStore	NoteStore authenticateToSharedNote authenticateToSharedNotebook copyNote createLinkedNotebook createNote createNotebook createOrUpdateNotebookShares createSearch createTag deleteNote emailNote expungeLinkedNotebook expungeNote expungeNotebook expungeSearch expungeTag findNoteCounts findNoteOffset findNotesMetadata findRelated getDefaultNotebook getFilteredSyncChunk getLinkedNotebookSyncChunk getLinkedNotebookSyncState getNote getNoteApplicationData getNoteApplicationDataEntry getNoteContent getNoteSearchText getNoteTagNames getNoteVersion getNoteWithResultSpec getNotebook getNotebookShares getPublicNotebook getResource getResourceAlternateData getResourceApplicationData getResourceApplicationDataEntry getResourceAttributes getResourceByHash getResourceData getResourceRecognition getResourceSearchText getSearch getSharedNotebookByAuth getSyncState getTag listAccessibleBusinessNotebooks listLinkedNotebooks listNoteVersions listNotebooks listSearches listSharedNotebooks listTags listTagsByNotebook manageNotebookShares setNoteApplicationDataEntry setNotebookRecipientSettings setResourceApplicationDataEntry shareNote shareNotebook stopSharingNote unsetNoteApplicationDataEntry unsetResourceApplicationDataEntry untagAll updateLinkedNotebook updateNote updateNoteIfUsnMatches updateNotebook updateResource updateSearch updateSharedNotebook updateTag	CreateOrUpdateNotebookSharesResult InvitationShareRelationship ManageNoteSharesError ManageNoteSharesParameters ManageNoteSharesResult ManageNotebookSharesError ManageNotebookSharesParameters ManageNotebookSharesResult MemberShareRelationship NoteCollectionCounts NoteEmailParameters NoteFilter NoteInvitationShareRelationship NoteList NoteMemberShareRelationship NoteMetadata NoteResultSpec NoteShareRelationshipRestrictions NoteShareRelationships NoteVersionId NotebookShareTemplate NotesMetadataList NotesMetadataResultSpec RelatedQuery RelatedResult RelatedResultSpec ShareRelationshipPrivilegeLevel ShareRelationshipRestrictions ShareRelationships SharedNoteTemplate SyncChunk SyncChunkFilter SyncState UpdateNoteIfUsnMatchesResult UserSetting

Enumeration: ShareRelationshipPrivilegeLevel

Privilege levels for accessing shared notebooks.

READ_NOTEBOOK: Recipient is able to read the contents of the shared notebook but does not have access to information about other recipients of the notebook or the activity stream information.

READ_NOTEBOOK_PLUS_ACTIVITY: Recipient has READ_NOTEBOOK rights and can also access information about other recipients and the activity stream.

MODIFY_NOTEBOOK_PLUS_ACTIVITY: Recipient has rights to read and modify the contents of the shared notebook, including the right to move notes to the trash and to create notes in the notebook. The recipient can also access information about other recipients and the activity stream.

FULL_ACCESS: Recipient has full rights to the shared notebook and recipient lists, including privilege to revoke and create invitations and to change privilege levels on invitations for individuals. If the user is a member of the same group, (e.g. the same business) as the shared notebook, they will additionally be granted permissions to update the publishing status of the notebook.

READ_NOTEBOOK 0

READ_NOTEBOOK_PLUS_ACTIVITY 10

MODIFY_NOTEBOOK_PLUS_ACTIVITY 20

FULL_ACCESS 30

Data structures

Struct: SyncState

Field	Type
currentTime	`Types.Timestamp`
fullSyncBefore	`Types.Timestamp`
updateCount	`i32`
uploaded	`i64`
userLastUpdated	`Types.Timestamp`
userMaxMessageEventId	`Types.MessageEventID`

This structure encapsulates the information about the state of the user's account for the purpose of "state based" synchronization.

currentTime

The server's current date and time.

fullSyncBefore

The cutoff date and time for client caches to be updated via incremental synchronization. Any clients that were last synched with the server before this date/time must do a full resync of all objects. This cutoff point will change over time as archival data is deleted or special circumstances on the service require resynchronization.

updateCount

Indicates the total number of transactions that have been committed within the account. This reflects (for example) the number of discrete additions or modifications that have been made to the data in this account (tags, notes, resources, etc.). This number is the "high water mark" for Update Sequence Numbers (USN) within the account.

uploaded

The total number of bytes that have been uploaded to this account in the current monthly period. This can be compared against Accounting.uploadLimit (from the UserStore) to determine how close the user is to their monthly upload limit. This value may not be present if the SyncState has been retrieved by a caller that only has read access to the account.

userLastUpdated

The last time when a user's account level information was changed. This value is the latest time when a modification was made to any of the following: accounting information (billing, quota, premium status, etc.), user attributes and business user information (business name, business user attributes, etc.) if the user is in a business. Clients who need to maintain account information about a User should watch this field for updates rather than polling UserStore.getUser for updates. Here is the basic flow that clients should follow:

Call NoteStore.getSyncState to retrieve the SyncState object
Compare SyncState.userLastUpdated to previously stored value: if (SyncState.userLastUpdated > previousValue) call UserStore.getUser to get the latest User object; else do nothing;
Update previousValue = SyncState.userLastUpdated

userMaxMessageEventId

The greatest MessageEventID for this user's account. Clients that do a full sync should store this value locally and compare their local copy to the value returned by getSyncState to determine if they need to sync with MessageStore. This value will be omitted if the user has never sent or received a message.

Struct: SyncChunk

Field	Type
currentTime	`Types.Timestamp`
chunkHighUSN	`i32`
updateCount	`i32`
notes	`list<Types.Note>`
notebooks	`list<Types.Notebook>`
tags	`list<Types.Tag>`
searches	`list<Types.SavedSearch>`
resources	`list<Types.Resource>`
expungedNotes	`list<Types.Guid>`
expungedNotebooks	`list<Types.Guid>`
expungedTags	`list<Types.Guid>`
expungedSearches	`list<Types.Guid>`
linkedNotebooks	`list<Types.LinkedNotebook>`
expungedLinkedNotebooks	`list<Types.Guid>`

This structure is given out by the NoteStore when a client asks to receive the current state of an account. The client asks for the server's state one chunk at a time in order to allow clients to retrieve the state of a large account without needing to transfer the entire account in a single message.

The server always gives SyncChunks using an ascending series of Update Sequence Numbers (USNs).

currentTime: The server's current date and time.
chunkHighUSN: The highest USN for any of the data objects represented in this sync chunk. If there are no objects in the chunk, this will not be set.
updateCount: The total number of updates that have been performed in the service for this account. This is equal to the highest USN within the account at the point that this SyncChunk was generated. If updateCount and chunkHighUSN are identical, that means that this is the last chunk in the account ... there is no more recent information.
notes: If present, this is a list of non-expunged notes that have a USN in this chunk. This will include notes that are "deleted" but not expunged (i.e. in the trash). The notes will include their list of tags and resources, but the note content, resource content, resource recognition data and resource alternate data will not be supplied.
notebooks: If present, this is a list of non-expunged notebooks that have a USN in this chunk.
tags: If present, this is a list of the non-expunged tags that have a USN in this chunk.
searches: If present, this is a list of non-expunged searches that have a USN in this chunk.
resources: If present, this is a list of the non-expunged resources that have a USN in this chunk. This will include the metadata for each resource, but not its binary contents or recognition data, which must be retrieved separately.
expungedNotes: If present, the GUIDs of all of the notes that were permanently expunged in this chunk.
expungedNotebooks: If present, the GUIDs of all of the notebooks that were permanently expunged in this chunk. When a notebook is expunged, this implies that all of its child notes (and their resources) were also expunged.
expungedTags: If present, the GUIDs of all of the tags that were permanently expunged in this chunk.
expungedSearches: If present, the GUIDs of all of the saved searches that were permanently expunged in this chunk.
linkedNotebooks: If present, this is a list of non-expunged LinkedNotebooks that have a USN in this chunk.
expungedLinkedNotebooks: If present, the GUIDs of all of the LinkedNotebooks that were permanently expunged in this chunk.

Struct: SyncChunkFilter

Field	Type
includeNotes	`bool`
includeNoteResources	`bool`
includeNoteAttributes	`bool`
includeNotebooks	`bool`
includeTags	`bool`
includeSearches	`bool`
includeResources	`bool`
includeLinkedNotebooks	`bool`
includeExpunged	`bool`
includeNoteApplicationDataFullMap	`bool`
includeResourceApplicationDataFullMap	`bool`
includeNoteResourceApplicationDataFullMap	`bool`
includeSharedNotes	`bool`
omitSharedNotebooks	`bool`
requireNoteContentClass	`string`
notebookGuids	`set<string>`

This structure is used with the 'getFilteredSyncChunk' call to provide fine-grained control over the data that's returned when a client needs to synchronize with the service. Each flag in this structure specifies whether to include one class of data in the results of that call.

includeNotes: If true, then the server will include the SyncChunks.notes field
includeNoteResources: If true, then the server will include the 'resources' field on all of the Notes that are in SyncChunk.notes. If 'includeNotes' is false, then this will have no effect.
includeNoteAttributes: If true, then the server will include the 'attributes' field on all of the Notes that are in SyncChunks.notes. If 'includeNotes' is false, then this will have no effect.
includeNotebooks: If true, then the server will include the SyncChunks.notebooks field
includeTags: If true, then the server will include the SyncChunks.tags field
includeSearches: If true, then the server will include the SyncChunks.searches field
includeResources: If true, then the server will include the SyncChunks.resources field. Since the Resources are also provided with their Note (in the Notes.resources list), this is primarily useful for clients that want to watch for changes to individual Resources due to recognition data being added.
includeLinkedNotebooks: If true, then the server will include the SyncChunks.linkedNotebooks field.
includeExpunged: If true, then the server will include the 'expunged' data for any type of included data. For example, if 'includeTags' and 'includeExpunged' are both true, then the SyncChunks.expungedTags field will be set with the GUIDs of tags that have been expunged from the server.
includeNoteApplicationDataFullMap: If true, then the values for the applicationData map will be filled in, assuming notes and note attributes are being returned. Otherwise, only the keysOnly field will be filled in.
includeResourceApplicationDataFullMap: If true, then the fullMap values for the applicationData map will be filled in, assuming resources and resource attributes are being returned (includeResources is true). Otherwise, only the keysOnly field will be filled in.
includeNoteResourceApplicationDataFullMap: If true, then the fullMap values for the applicationData map will be filled in for resources found inside of notes, assuming resources are being returned in notes (includeNoteResources is true). Otherwise, only the keysOnly field will be filled in.
omitSharedNotebooks
: Normally, if 'includeNotebooks' is true, then the SyncChunks will include Notebooks that may include a set of SharedNotebook invitations via Notebook.sharedNotebookIds and Notebook.sharedNotebooks. However, if omitSharedNotebooks is set to true, then the Notebooks will omit those two fields and leave them unset. This should be used by clients who want to know their own set of Notebooks (and the associated permissions via Notebook.recipientSettings), and who do not need to know the full set of other people who can also see that same notebook.
requireNoteContentClass: If set, then only send notes whose content class matches this value. The value can be a literal match or, if the last character is an asterisk, a prefix match.
notebookGuids: If set, then restrict the returned notebooks, notes, and resources to those associated with one of the notebooks whose GUID is provided in this list. If not set, then no filtering on notebook GUID will be performed. If you set this field, you may not also set includeExpunged else an EDAMUserException with an error code of DATA_CONFLICT will be thrown. You only need to set this field if you want to restrict the returned entities more than what your authentication token allows you to access. For example, there is no need to set this field for single notebook tokens such as for shared notebooks. You can use this field to synchronize a newly discovered business notebook while incrementally synchronizing a business account, in which case you will only need to consider setting includeNotes, includeNotebooks, includeNoteAttributes, includeNoteResources, and maybe some of the "FullMap" fields.
includeSharedNotes: If true, then the service will include the sharedNotes field on all notes that are in SyncChunk.notes. If 'includeNotes' is false, then this will have no effect.

Struct: NoteFilter

Field	Type
order	`i32`
ascending	`bool`
words	`string`
notebookGuid	`Types.Guid`
tagGuids	`list<Types.Guid>`
timeZone	`string`
inactive	`bool`
emphasized	`string`
includeAllReadableNotebooks	`bool`

A list of criteria that are used to indicate which notes are desired from the account. This is used in queries to the NoteStore to determine which notes should be retrieved.

order: The NoteSortOrder value indicating what criterion should be used to sort the results of the filter.
ascending: If true, the results will be ascending in the requested sort order. If false, the results will be descending.
words: If present, a search query string that will filter the set of notes to be returned. Accepts the full search grammar documented in the Evernote API Overview.
notebookGuid: If present, the Guid of the notebook that must contain the notes.
tagGuids: If present, the list of tags (by GUID) that must be present on the notes.
timeZone: The zone ID for the user, which will be used to interpret any dates or times in the queries that do not include their desired zone information. For example, if a query requests notes created "yesterday", this will be evaluated from the provided time zone, if provided. The format must be encoded as a standard zone ID such as "America/Los_Angeles".
inactive: If true, then only notes that are not active (i.e. notes in the Trash) will be returned. Otherwise, only active notes will be returned. There is no way to find both active and inactive notes in a single query.
emphasized: If present, a search query string that may or may not influence the notes to be returned, both in terms of coverage as well as of order. Think of it as a wish list, not a requirement. Accepts the full search grammar documented in the Evernote API Overview.
includeAllReadableNotebooks: If true, then the search will include all business notebooks that are readable by the user. A business authentication token must be supplied for this option to take effect when calling search APIs.

Struct: NoteList

Field	Type
startIndex	`i32`
totalNotes	`i32`
notes	`list<Types.Note>`
stoppedWords	`list<string>`
searchedWords	`list<string>`
updateCount	`i32`

A small structure for returning a list of notes out of a larger set.

startIndex: The starting index within the overall set of notes. This is also the number of notes that are "before" this list in the set.
totalNotes: The number of notes in the larger set. This can be used to calculate how many notes are "after" this note in the set. (I.e. remaining = totalNotes - (startIndex + notes.length) )
notes: The list of notes from this range. The Notes will include all metadata (attributes, resources, etc.), but will not include the ENML content of the note or the binary contents of any resources.
stoppedWords: If the NoteList was produced using a text based search query that included words that are not indexed or searched by the service, this will include a list of those ignored words.
searchedWords: If the NoteList was produced using a text based search query that included viable search words or quoted expressions, this will include a list of those words. Any stopped words will not be included in this list.
updateCount: Indicates the total number of transactions that have been committed within the account. This reflects (for example) the number of discrete additions or modifications that have been made to the data in this account (tags, notes, resources, etc.). This number is the "high water mark" for Update Sequence Numbers (USN) within the account.

Struct: NoteMetadata

Field	Type
guid	`Types.Guid`
title	`string`
contentLength	`i32`
created	`Types.Timestamp`
updated	`Types.Timestamp`
deleted	`Types.Timestamp`
updateSequenceNum	`i32`
notebookGuid	`string`
tagGuids	`list<Types.Guid>`
attributes	`Types.NoteAttributes`
largestResourceMime	`string`
largestResourceSize	`i32`

This structure is used in the set of results returned by the findNotesMetadata function. It represents the high-level information about a single Note, without some of the larger deep structure. This allows for the information about a list of Notes to be returned relatively quickly with less marshalling and data transfer to remote clients. Most fields in this structure are identical to the corresponding field in the Note structure, with the exception of:

largestResourceMime: If set, then this will contain the MIME type of the largest Resource (in bytes) within the Note. This may be useful, for example, to choose an appropriate icon or thumbnail to represent the Note.
largestResourceSize: If set, this will contain the size of the largest Resource file, in bytes, within the Note. This may be useful, for example, to decide whether to ask the server for a thumbnail to represent the Note.

Struct: NotesMetadataList

Field	Type
startIndex	`i32`
totalNotes	`i32`
notes	`list<NoteMetadata>`
stoppedWords	`list<string>`
searchedWords	`list<string>`
updateCount	`i32`

This structure is returned from calls to the findNotesMetadata function to give the high-level metadata about a subset of Notes that are found to match a specified NoteFilter in a search.

startIndex: The starting index within the overall set of notes. This is also the number of notes that are "before" this list in the set.
totalNotes: The number of notes in the larger set. This can be used to calculate how many notes are "after" this note in the set. (I.e. remaining = totalNotes - (startIndex + notes.length) )
notes: The list of metadata for Notes in this range. The set of optional fields that are set in each metadata structure will depend on the NotesMetadataResultSpec provided by the caller when the search was performed. Only the 'guid' field will be guaranteed to be set in each Note.
stoppedWords: If the NoteList was produced using a text based search query that included words that are not indexed or searched by the service, this will include a list of those ignored words.
searchedWords: If the NoteList was produced using a text based search query that included viable search words or quoted expressions, this will include a list of those words. Any stopped words will not be included in this list.
updateCount: Indicates the total number of transactions that have been committed within the account. This reflects (for example) the number of discrete additions or modifications that have been made to the data in this account (tags, notes, resources, etc.). This number is the "high water mark" for Update Sequence Numbers (USN) within the account.

Struct: NotesMetadataResultSpec

Field	Type
includeTitle	`bool`
includeContentLength	`bool`
includeCreated	`bool`
includeUpdated	`bool`
includeDeleted	`bool`
includeUpdateSequenceNum	`bool`
includeNotebookGuid	`bool`
includeTagGuids	`bool`
includeAttributes	`bool`
includeLargestResourceMime	`bool`
includeLargestResourceSize	`bool`

This structure is provided to the findNotesMetadata function to specify the subset of fields that should be included in each NoteMetadata element that is returned in the NotesMetadataList. Each field on this structure is a boolean flag that indicates whether the corresponding field should be included in the NoteMetadata structure when it is returned. For example, if the 'includeTitle' field is set on this structure when calling findNotesMetadata, then each NoteMetadata in the list should have its 'title' field set. If one of the fields in this spec is not set, then it will be treated as 'false' by the server, so the default behavior is to include nothing in replies (but the mandatory GUID)

Struct: NoteCollectionCounts

Field	Type
notebookCounts	`map<Types.Guid, i32>`
tagCounts	`map<Types.Guid, i32>`
trashCount	`i32`

A data structure representing the number of notes for each notebook and tag with a non-zero set of applicable notes.

notebookCounts: A mapping from the Notebook GUID to the number of notes (from some selection) that are in the corresponding notebook.
tagCounts: A mapping from the Tag GUID to the number of notes (from some selection) that have the corresponding tag.
trashCount: If this is set, then this is the number of notes that are in the trash. If this is not set, then the number of notes in the trash hasn't been reported. (I.e. if there are no notes in the trash, this will be set to 0.)

Struct: NoteResultSpec

Field	Type
includeContent	`bool`
includeResourcesData	`bool`
includeResourcesRecognition	`bool`
includeResourcesAlternateData	`bool`
includeSharedNotes	`bool`
includeNoteAppDataValues	`bool`
includeResourceAppDataValues	`bool`
includeAccountLimits	`bool`

This structure is provided to the getNoteWithResultSpec function to specify the subset of fields that should be included in the Note that is returned. This allows clients to request the minimum set of information that they require when retrieving a note, reducing the size of the response and improving the response time.

If one of the fields in this spec is not set, then it will be treated as 'false' by the service, so that the default behavior is to include none of the fields below in the Note.

includeContent: If true, the Note.content field will be populated with the note's ENML contents.
includeResourcesData: If true, any Resource elements will include the binary contents of their 'data' field's body.
includeResourcesRecognition: If true, any Resource elements will include the binary contents of their 'recognition' field's body if recognition data is available.
includeResourcesAlternateData: If true, any Resource elements will include the binary contents of their 'alternateData' field's body, if an alternate form is available.
includeSharedNotes: If true, the Note.sharedNotes field will be populated with the note's shares.
includeNoteAppDataValues: If true, the Note.attributes.applicationData.fullMap field will be populated.
includeResourceAppDataValues: If true, the Note.resource.attributes.applicationData.fullMap field will be populated.
includeAccountLimits: If true, the Note.limits field will be populated with the note owner's account limits.

Struct: NoteEmailParameters

Field	Type
guid	`string`
note	`Types.Note`
toAddresses	`list<string>`
ccAddresses	`list<string>`
subject	`string`
message	`string`

Parameters that must be given to the NoteStore emailNote call. These allow the caller to specify the note to send, the recipient addresses, etc.

guid: If set, this must be the GUID of a note within the user's account that should be retrieved from the service and sent as email. If not set, the 'note' field must be provided instead.
note: If the 'guid' field is not set, this field must be provided, including the full contents of the note note (and all of its Resources) to send. This can be used for a Note that as not been created in the service, for example by a local client with local notes.
toAddresses: If provided, this should contain a list of the SMTP email addresses that should be included in the "To:" line of the email. Callers must specify at least one "to" or "cc" email address.
ccAddresses: If provided, this should contain a list of the SMTP email addresses that should be included in the "Cc:" line of the email. Callers must specify at least one "to" or "cc" email address.
subject: If provided, this should contain the subject line of the email that will be sent. If not provided, the title of the note will be used as the subject of the email.
message: If provided, this is additional personal text that should be included into the email as a message from the owner to the recipient(s).

Struct: NoteVersionId

Field	Type
updateSequenceNum	`i32`
updated	`Types.Timestamp`
saved	`Types.Timestamp`
title	`string`
lastEditorId	`Types.UserID`

Identifying information about previous versions of a note that are backed up within Evernote's servers. Used in the return value of the listNoteVersions call.

updateSequenceNum: The update sequence number for the Note when it last had this content. This serves to uniquely identify each version of the note, since USN values are unique within an account for each update.
updated: The 'updated' time that was set on the Note when it had this version of the content. This is the user-modifiable modification time on the note, so it's not reliable for guaranteeing the order of various versions. (E.g. if someone modifies the note, then changes this time manually into the past and then updates the note again.)
saved: A timestamp that holds the date and time when this version of the note was backed up by Evernote's servers.
title: The title of the note when this particular version was saved. (The current title of the note may differ from this value.)
lastEditorId: The ID of the user who made the change to this version of the note. This will be unset if the note version was edited by the owner of the account.

Struct: RelatedQuery

Field	Type
noteGuid	`string`
plainText	`string`
filter	`NoteFilter`
referenceUri	`string`
context	`string`
cacheKey	`string`

A description of the thing for which we are searching for related entities.

You must specify either noteGuid or plainText, but not both. filter and referenceUri are optional.

noteGuid

The GUID of an existing note in your account for which related entities will be found.

plainText

A string of plain text for which to find related entities. You should provide a text block with a number of characters between EDAM_RELATED_PLAINTEXT_LEN_MIN and EDAM_RELATED_PLAINTEXT_LEN_MAX.

filter

The list of criteria that will constrain the notes being considered related. Please note that some of the parameters may be ignored, such as order and ascending.

referenceUri

A URI string specifying a reference entity, around which "relatedness" should be based. This can be an URL pointing to a web page, for example.

context

Specifies the context to consider when determining related results. Clients must leave this value unset unless they wish to explicitly specify a known non-default context.

cacheKey

If set and non-empty, this is an indicator for the server whether it is actually necessary to perform a new findRelated call at all. Cache Keys are opaque strings which are returned by the server as part of "RelatedResult" in response to a "NoteStore.findRelated" query. Cache Keys are inherently query specific.

If set to an empty string, this indicates that the server should generate a cache key in the response as part of "RelatedResult".

If not set, the server will not attempt to generate a cache key at all.

Struct: RelatedResult

Field	Type
notes	`list<Types.Note>`
notebooks	`list<Types.Notebook>`
tags	`list<Types.Tag>`
containingNotebooks	`list<Types.NotebookDescriptor>`
debugInfo	`string`
experts	`list<Types.UserProfile>`
relatedContent	`list<Types.RelatedContent>`
cacheKey	`string`
cacheExpires	`i32`

The result of calling findRelated(). The contents of the notes, notebooks, and tags fields will be in decreasing order of expected relevance. It is possible that fewer results than requested will be returned even if there are enough distinct entities in the account in cases where the relevance is estimated to be low.

notes

If notes have been requested to be included, this will be the list of notes.

notebooks

If notebooks have been requested to be included, this will be the list of notebooks.

tags

If tags have been requested to be included, this will be the list of tags.

containingNotebooks

If includeContainingNotebooks is set to true in the RelatedResultSpec, return the list of notebooks to to which the returned related notes belong. The notebooks in this list will occur once per notebook GUID and are represented as NotebookDescriptor objects.

debugInfo

If includeDebugInfo in RelatedResultSpec is set to true, this field may contain debug information if the service decides to do so.

experts

If experts have been requested to be included, this will return a list of users within your business who have knowledge about the specified query.

relatedContent

If related content has been requested to be included, this will be the list of related content snippets.

cacheKey

If set and non-empty, this cache key may be used in subsequent "NoteStore.findRelated" calls (via "RelatedQuery") to re-use previous responses that were cached on the client-side, instead of actually performing another search.

If set to an empty string, this indicates that the server could not determine a specific key for this response, but the client should nevertheless remove any previously cached result for this request.

If unset/null, it is up to the client whether to re-use cached results or to use the server's response.

If set to the exact non-empty cache key that was specified in "RelatedQuery.cacheKey", this indicates that the server decided that cached results could be reused.

Depending on the cache key specified in the query, the "RelatedResult" may only be partially filled. For each set field, the client should replace the corresponding part in the previously cached result with the new partial result. For example, for a specific query that has both "RelatedResultSpec.maxNotes" and "RelatedResultSpec.maxRelatedContent" set to positive values, the server may decide that the previously requested and cached Related Content are unchanged, but new results for Related Notes are available. The response will have a new cache key and have "RelatedResult.notes" set, but have "RelatedResult.relatedContent" unset (not just empty, but really unset).

In this situation, the client should replace any cached notes with the newly returned "RelatedResult.notes", but it can re-use the previously cached entries for "RelatedResult.relatedContent". List fields that are set, but empty indicate that no results could be found; the cache should be updated correspondingly.

cacheExpires

If set, clients should reuse this response for any situations where the same input parameters are applicable for up to this many seconds after receiving this result.

After this time has passed, the client may request a new result from the service, but it should supply the stored cacheKey to the service when checking for an update.

Struct: RelatedResultSpec

Field	Type
maxNotes	`i32`
maxNotebooks	`i32`
maxTags	`i32`
writableNotebooksOnly	`bool`
includeContainingNotebooks	`bool`
includeDebugInfo	`bool`
maxExperts	`i32`
maxRelatedContent	`i32`
relatedContentTypes	`set<Types.RelatedContentType>`

A description of the thing for which the service will find related entities, via findRelated(), together with a description of what type of entities and how many you are seeking in the RelatedResult.

maxNotes: Return notes that are related to the query, but no more than this many. Any value greater than EDAM_RELATED_MAX_NOTES will be silently capped. If you do not set this field, then no notes will be returned.
maxNotebooks: Return notebooks that are related to the query, but no more than this many. Any value greater than EDAM_RELATED_MAX_NOTEBOOKS will be silently capped. If you do not set this field, then no notebooks will be returned.
maxTags: Return tags that are related to the query, but no more than this many. Any value greater than EDAM_RELATED_MAX_TAGS will be silently capped. If you do not set this field, then no tags will be returned.

writableNotebooksOnly

Require that all returned related notebooks are writable. The user will be able to create notes in all returned notebooks. However, individual notes returned may still belong to notebooks in which the user lacks the ability to create notes.

includeContainingNotebooks

If set to true, return the containingNotebooks field in the RelatedResult, which will contain the list of notebooks to to which the returned related notes belong.

includeDebugInfo

If set to true, indicate that debug information should be returned in the 'debugInfo' field of RelatedResult. Note that the call may be slower if this flag is set.

maxExperts

This can only be used when making a findRelated call against a business. Find users within your business who have knowledge about the specified query. No more than this many users will be returned. Any value greater than EDAM_RELATED_MAX_EXPERTS will be silently capped.

maxRelatedContent

Return snippets of related content that is related to the query, but no more than this many. Any value greater than EDAM_RELATED_MAX_RELATED_CONTENT will be silently capped. If you do not set this field, then no related content will be returned.

relatedContentTypes

Specifies the types of Related Content that should be returned.

Struct: UpdateNoteIfUsnMatchesResult

Field	Type
note	`Types.Note`
updated	`bool`

The result of a call to updateNoteIfUsnMatches, which optionally updates a note based on the current value of the note's update sequence number on the service.

note: Either the current state of the note if updated is false or the result of updating the note as would be done via the updateNote method. If the note was not updated, you will receive a Note that does not include note content, resources data, resources recognition data, or resources alternate data. You can check for updates to these large objects by checking the Data.bodyHash values and downloading accordingly.
updated: Whether or not the note was updated by the operation.

Struct: ShareRelationshipRestrictions

Field	Type
noSetReadOnly	`bool`
noSetReadPlusActivity	`bool`
noSetModify	`bool`
noSetFullAccess	`bool`

Struct: InvitationShareRelationship

Field	Type
displayName	`string`
recipientUserIdentity	`Types.UserIdentity`
privilege	`ShareRelationshipPrivilegeLevel`
sharerUserId	`Types.UserID`

Describes an invitation to a person to use their Evernote credentials to become a member of a notebook.

displayName: The string that clients should show to users to represent this invitation.
recipientUserIdentity: Identifies the recipient of the invitation. The user identity type can be either EMAIL or IDENTITYID, depending on whether the invitation was created using the classic notebook sharing APIs or the new identity-based notebook sharing APIs.
privilege: The privilege level at which the member will be joined, if it turns out that the member is not already joined at a higher level. Note that the identity field may not uniquely identify an Evernote User ID, and so we won't know until the invitation is redeemed whether or not the recipient already has privilege.
sharerUserId: The user id of the user who most recently shared this notebook to this identity. This field is used by the service to convey information to the user, so clients should treat it as read-only.

Struct: MemberShareRelationship

Field	Type
displayName	`string`
recipientUserId	`Types.UserID`
bestPrivilege	`ShareRelationshipPrivilegeLevel`
individualPrivilege	`ShareRelationshipPrivilegeLevel`
restrictions	`ShareRelationshipRestrictions`
sharerUserId	`Types.UserID`

Describes the association between a Notebook and an Evernote User who is a member of that notebook.

displayName: The string that clients should show to users to represent this member.
recipientUserId: The Evernote User ID of the recipient of this notebook share.
bestPrivilege: The privilege at which the member can access the notebook, which is the best privilege granted either individually or to a group to which a member belongs, such as a business. This field is used by the service to convey information to the user, so clients should treat it as read-only.
individualPrivilege: The individually granted privilege for the member, which does not take GROUP privileges into account. This value may be unset if only a group-assigned privilege has been granted to the member. This value can be managed by others with sufficient rights using the manageNotebookShares method. The valid values that clients should present to users for selection are given via the the 'restrictions' field.
restrictions: The restrictions on which privileges may be individually assigned to the recipient of this share relationship.
sharerUserId: The user id of the user who most recently shared the notebook to this user. This field is currently unset for a MemberShareRelationship created by joining a notebook that has been published to the business (MemberShareRelationships where the individual privilege is unset). This field is used by the service to convey information to the user, so clients should treat it as read-only.

Struct: ShareRelationships

Field	Type
invitations	`list<InvitationShareRelationship>`
memberships	`list<MemberShareRelationship>`
invitationRestrictions	`ShareRelationshipRestrictions`

Captures a collection of share relationships for a notebook, for example, as returned by the getNotebookShares method. The share relationships fall into two broad categories: members, and invitations that can be used to become members.

invitations: A list of open invitations that can be redeemed into memberships to the notebook.
memberships: A list of memberships of the notebook. A member is identified by their Evernote UserID and has rights to access the notebook.
invitationRestrictions: The restrictions on what privileges may be granted to invitees to this notebook. These restrictions may be specific to the calling user or to the notebook itself. They represent the union of all possible invite cases, so it is possible that once the recipient of the invitation has been identified by the service, such as by a business auto-join, the actual assigned privilege may change.

Struct: ManageNotebookSharesParameters

Field	Type
notebookGuid	`string`
inviteMessage	`string`
membershipsToUpdate	`list<MemberShareRelationship>`
invitationsToCreateOrUpdate	`list<InvitationShareRelationship>`
unshares	`list<Types.UserIdentity>`

A structure that captures parameters used by clients to manage the shares for a given notebook via the manageNotebookShares method.

notebookGuid: The GUID of the notebook whose shares are being managed.
inviteMessage: If the service sends a message to invitees, this parameter will be used to form the actual message that is sent.
membershipsToUpdate: The list of existing memberships to update. This field is not intended to be the full set of memberships for the notebook and should only include those already-existing memberships that you actually want to change. If you want to remove shares, see the unshares fields. If you want to create a membership, i.e. auto-join a business user, you can do this via the invitationsToCreateOrUpdate field using an Evernote UserID of a fellow business member (the created invitation is automatically joined by the service, so the client is creating an invitation, not a membership).
invitationsToCreateOrUpdate: The list of invitations to update, as matched by the identity field of the InvitationShareRelationship instances, or to create if an existing invitation does not exist. This field is not intended to be the full set of invitations on the notebook and should only include those invitations that you wish to create or update. Note that your invitation could convert into a membership via a service-supported auto-join operation. This happens, for example, when you use an invitation with an Evernote UserID type for a recipient who is a member of the business to which the notebook belongs. Note that to discover the user IDs for business members, the sharer must also be part of the business.
unshares: The list of share relationships to expunge from the service. If the user identity is for an Evernote UserID, then memberships will be removed. If it's an e-mail, then e-mail based shared notebook invitations will be removed. If it's for an Identity ID, then any invitations that match the identity (by identity ID or user ID or e-mail for legacy invitations) will be removed.

Struct: ManageNotebookSharesError

Field	Type
userIdentity	`Types.UserIdentity`
userException	`Errors.EDAMUserException`
notFoundException	`Errors.EDAMNotFoundException`

A structure to capture certain errors that occurred during a call to manageNotebookShares. That method can be run best-effort, meaning that some change requests can be applied while others fail. Note that some errors such as system errors will still fail the entire transaction regardless of running best effort. When some change requests do not succeed, the error conditions are captured in instances of this class, captured by the identity of the share relationship and one of the exception fields.

userIdentity: The identity of the share relationship whose update encountered an error.
userException: If the error is represented as an EDAMUserException that would have otherwise been thrown without best-effort execution. Only one exception field will be set.
notFoundException: If the error is represented as an EDAMNotFoundException that would have otherwise been thrown without best-effort execution. Only one exception field will be set.

Struct: ManageNotebookSharesResult

Field	Type
errors	`list<ManageNotebookSharesError>`

The return value of a call to the manageNotebookShares method.

errors: If the method completed without throwing exceptions, some errors might still have occurred, and in that case, this field will contain the list of those errors the occurred.

Struct: SharedNoteTemplate

Field	Type
noteGuid	`Types.Guid`
recipientThreadId	`Types.MessageThreadID`
recipientContacts	`list<Types.Contact>`
privilege	`Types.SharedNotePrivilegeLevel`

A structure used to share a note with one or more recipients at a given privilege.

noteGuid: The GUID of the note.
recipientThreadId: The recipients of the note share specified as a messaging thread ID. If you have an existing messaging thread to share the note with, specify its ID here instead of recipientContacts in order to properly support defunct identities. The sharer must be a participant of the thread. Either this field or recipientContacts must be set.
recipientContacts: The recipients of the note share specified as a list of contacts. This should only be set if the sharing takes place before the thread is created. Use recipientThreadId instead when sharing with an existing thread. Either this field or recipientThreadId must be set.
privilege: The privilege level to be granted.

Struct: NotebookShareTemplate

Field	Type
notebookGuid	`Types.Guid`
recipientThreadId	`Types.MessageThreadID`
recipientContacts	`list<Types.Contact>`
privilege	`Types.SharedNotebookPrivilegeLevel`

A structure used to share a notebook with one or more recipients at a given privilege.

notebookGuid: The GUID of the notebook.
recipientThreadId: The recipients of the notebook share specified as a messaging thread ID. If you have an existing messaging thread to share the note with, specify its ID here instead of recipientContacts in order to properly support defunct identities. The sharer must be a participant of the thread. Either this field or recipientContacts must be set.
recipientContacts: The recipients of the notebook share specified as a list of contacts. This should only be set if the sharing takes place before the thread is created. Use recipientThreadId instead when sharing with an existing thread. Either this field or recipientThreadId must be set.
privilege: The privilege level to be granted.

Struct: CreateOrUpdateNotebookSharesResult

Field	Type
updateSequenceNum	`i32`
matchingShares	`list<Types.SharedNotebook>`

A structure containing the results of a call to createOrUpdateNotebookShares.

updateSequenceNum: The USN of the notebook after the call.
matchingShares: A list of SharedNotebook records that match the desired recipients. These records may have been either created or updated by the call to createOrUpdateNotebookShares, or they may have been at the desired privilege privilege level prior to the call.

Struct: NoteShareRelationshipRestrictions

Field	Type
noSetReadNote	`bool`
noSetModifyNote	`bool`
noSetFullAccess	`bool`

This structure is used by the service to communicate to clients, via getNoteShareRelationships, which privilege levels are assignable to the target of a note share relationship.

noSetReadNote: This value is true if the user is not allowed to set the privilege level to SharedNotePrivilegeLevel.READ_NOTE.
noSetModifyNote: This value is true if the user is not allowed to set the privilege level to SharedNotePrivilegeLevel.MODIFY_NOTE.
noSetFullAccess: This value is true if the user is not allowed to set the privilege level to SharedNotePrivilegeLevel.FULL_ACCESS.

Struct: NoteMemberShareRelationship

Field	Type
displayName	`string`
recipientUserId	`Types.UserID`
privilege	`Types.SharedNotePrivilegeLevel`
restrictions	`NoteShareRelationshipRestrictions`
sharerUserId	`Types.UserID`

Describes the association between a Note and an Evernote User who is a member of that note.

displayName: The string that clients should show to users to represent this member.
recipientUserId: The Evernote UserID of the user who is a member to the note.
privilege: The privilege at which the member can access the note, which is the best privilege granted to the user across all of their individual shares for this note. This field is used by the service to convey information to the user, so clients should treat it as read-only.
restrictions: The restrictions on which privileges may be individually assigned to the recipient of this share relationship. This field is used by the service to convey information to the user, so clients should treat it as read-only.
sharerUserId: The user id of the user who most recently shared the note with this user. This field is used by the service to convey information to the user, so clients should treat it as read-only.

Struct: NoteInvitationShareRelationship

Field	Type
displayName	`string`
recipientIdentityId	`Types.IdentityID`
privilege	`Types.SharedNotePrivilegeLevel`
sharerUserId	`Types.UserID`

Describes an invitation to a person to use their Evernote credentials to gain access to a note belonging to another user.

displayName: The string that clients should show to users to represent this invitation.
recipientIdentityId: Identifies the identity of the invitation recipient. Once the identity has been claimed by an Evernote user and they have accessed the note at least once, the invitation will be used up and will no longer be returned by the service to clients. Instead, that recipient will be included in the list of NoteMemberShareRelationships.
privilege: The privilege level that the recipient will be granted when they accept this invitation. If the user already has a higher privilege to access this note then this will not affect the recipient's privileges.
sharerUserId: The user id of the user who most recently shared this note to this recipient. This field is used by the service to convey information to the user, so clients should treat it as read-only.

Struct: NoteShareRelationships

Field	Type
invitations	`list<NoteInvitationShareRelationship>`
memberships	`list<NoteMemberShareRelationship>`
invitationRestrictions	`NoteShareRelationshipRestrictions`

Captures a collection of share relationships for a single note, for example, as returned by the getNoteShares method. The share relationships fall into two broad categories: members, and invitations that can be used to become members.

invitations: A list of open invitations that can be redeemed into memberships to the note.
memberships: A list of memberships of the noteb. A member is identified by their Evernote UserID and has rights to access the note.
restrictions: The restrictions on which privileges may be assigned to the recipient of an open invitation. These restrictions only apply to invitations; restrictions on memberships are specified on the NoteMemberShareRelationship. This field is used by the service to convey information to the user, so clients should treat it as read-only.

Struct: ManageNoteSharesParameters

Field	Type
noteGuid	`string`
membershipsToUpdate	`list<NoteMemberShareRelationship>`
invitationsToUpdate	`list<NoteInvitationShareRelationship>`
membershipsToUnshare	`list<Types.UserID>`
invitationsToUnshare	`list<Types.IdentityID>`

Captures parameters used by clients to manage the shares for a given note via the manageNoteShares function. This is used only to manage the existing memberships and invitations for a note. To invite a new recipient, use NoteStore.createOrUpdateSharedNotes.

The only field of an existing membership or invitation that can be updated by this function is the share privilege.

noteGuid: The GUID of the note whose shares are being managed.
membershipsToUpdate: A list of existing memberships to update. This field is not meant to be the full set of memberships for the note. Clients should only include those existing memberships that they wish to modify. To remove an existing membership, see the unshares field.
invitationsToUpdate: The list of outstanding invitations to update, as matched by the identity field of the NoteInvitationShareRelatioship instances. This field is not meant to be the full set of invitations for the note. Clients should only include those existing invitations that they wish to modify.
membershipsToUnshare: A list of existing memberships to expunge from the service.
invitationsToUnshare: A list of outstanding invitations to expunge from the service.

Struct: ManageNoteSharesError

Field	Type
identityID	`Types.IdentityID`
userID	`Types.UserID`
userException	`Errors.EDAMUserException`
notFoundException	`Errors.EDAMNotFoundException`

Captures errors that occur during a call to manageNoteShares. That function can be run best-effort, meaning that some change requests can be applied while others fail. Note that some errors such as system exceptions may still cause the entire call to fail.

Only one of the two ID fields will be set on a given error.

Only one of the two exception fields will be set on a given error.

identityID: The identity ID of an outstanding invitation that was not updated due to the error.
userID: The user ID of an existing membership that was not updated due to the error.
userException: If the error is represented as an EDAMUserException that would have otherwise been thrown without best-effort execution.
notFoundException: If the error is represented as an EDAMNotFoundException that would have otherwise been thrown without best-effort execution. The identifier field of the exception will be either "Identity.id" or "User.id", indicating that no existing share could be found for the specified recipient.

Struct: ManageNoteSharesResult

Field	Type
errors	`list<ManageNoteSharesError>`

The return value of a call to the manageNoteShares function.

errors: If the call succeeded without throwing an exception, some errors might still have occurred. In that case, this field will contain the list of errors.

Services

Service: NoteStore

The NoteStore service is used by EDAM clients to exchange information about the collection of notes in an account. This is primarily used for synchronization, but could also be used by a "thin" client without a full local cache.

Most functions take an "authenticationToken" parameter, which is the value returned by the UserStore which permits access to the account.

Calls which require an authenticationToken may throw an EDAMUserException for the following reasons:

Function: NoteStore.getSyncState

SyncState getSyncState(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Asks the NoteStore to provide information about the status of the user account corresponding to the provided authentication token.

Function: NoteStore.getFilteredSyncChunk

SyncChunk getFilteredSyncChunk(string authenticationToken,
                               i32 afterUSN,
                               i32 maxEntries,
                               SyncChunkFilter filter)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Asks the NoteStore to provide the state of the account in order of last modification. This request retrieves one block of the server's state so that a client can make several small requests against a large account rather than getting the entire state in one big message. This call gives fine-grained control of the data that will be received by a client by omitting data elements that a client doesn't need. This may reduce network traffic and sync times.

@param afterUSN The client can pass this value to ask only for objects that have been updated after a certain point. This allows the client to receive updates after its last checkpoint rather than doing a full synchronization on every pass. The default value of "0" indicates that the client wants to get objects from the start of the account.

@param filter The caller must set some of the flags in this structure to specify which data types should be returned during the synchronization. See the SyncChunkFilter structure for information on each flag.

@throws EDAMUserException

BAD_DATA_FORMAT "afterUSN" - if negative
BAD_DATA_FORMAT "maxEntries" - if less than 1

Function: NoteStore.getLinkedNotebookSyncState

SyncState getLinkedNotebookSyncState(string authenticationToken,
                                     Types.LinkedNotebook linkedNotebook)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Asks the NoteStore to provide information about the status of a linked notebook that has been shared with the caller, or that is public to the world. This will return a result that is similar to getSyncState, but may omit SyncState.uploaded if the caller doesn't have permission to write to the linked notebook.

This function must be called on the shard that owns the referenced notebook. (I.e. the shardId in /shard/shardId/edam/note must be the same as LinkedNotebook.shardId.)

@param authenticationToken This should be an authenticationToken for the guest who has received the invitation to the share. (I.e. this should not be the result of NoteStore.authenticateToSharedNotebook)

@param linkedNotebook This structure should contain identifying information and permissions to access the notebook in question.

@throws EDAMUserException

DATA_REQUIRED "LinkedNotebook.username" - The username field must be populated with the current username of the owner of the notebook for which you are obtaining sync state.

@throws EDAMNotFoundException

"LinkedNotebook.username" - If the LinkedNotebook.username field does not correspond to a current user on the service.

@throws SystemException

SHARD_UNAVAILABLE - If the provided LinkedNotebook.username corresponds to a user whose account is on a shard other than that on which this method was invoked.

Function: NoteStore.getLinkedNotebookSyncChunk

SyncChunk getLinkedNotebookSyncChunk(string authenticationToken,
                                     Types.LinkedNotebook linkedNotebook,
                                     i32 afterUSN,
                                     i32 maxEntries,
                                     bool fullSyncOnly)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Asks the NoteStore to provide information about the contents of a linked notebook that has been shared with the caller, or that is public to the world. This will return a result that is similar to getSyncChunk, but will only contain entries that are visible to the caller. I.e. only that particular Notebook will be visible, along with its Notes, and Tags on those Notes.

This function must be called on the shard that owns the referenced notebook. (I.e. the shardId in /shard/shardId/edam/note must be the same as LinkedNotebook.shardId.)

@param linkedNotebook This structure should contain identifying information and permissions to access the notebook in question. This must contain the valid fields for either a shared notebook (e.g. shareKey) or a public notebook (e.g. username, uri)

@param maxEntries The maximum number of modified objects that should be returned in the result SyncChunk. This can be used to limit the size of each individual message to be friendly for network transfer. Applications should not request more than 256 objects at a time, and must handle the case where the service returns less than the requested number of objects in a given request even though more objects are available on the service.

@param fullSyncOnly If true, then the client only wants initial data for a full sync. In this case, the service will not return any expunged objects, and will not return any Resources, since these are also provided in their corresponding Notes.

@throws EDAMUserException

BAD_DATA_FORMAT "afterUSN" - if negative
BAD_DATA_FORMAT "maxEntries" - if less than 1

@throws EDAMNotFoundException

"LinkedNotebook" - if the provided information doesn't match any valid notebook
"LinkedNotebook.uri" - if the provided public URI doesn't match any valid notebook
"SharedNotebook.id" - if the provided information indicates a shared notebook that no longer exists

Function: NoteStore.listNotebooks

list<Types.Notebook> listNotebooks(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Returns a list of all of the notebooks in the account.

Function: NoteStore.listAccessibleBusinessNotebooks

list<Types.Notebook> listAccessibleBusinessNotebooks(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Returns a list of all the notebooks in a business that the user has permission to access, regardless of whether the user has joined them. This includes notebooks that have been shared with the entire business as well as notebooks that have been shared directly with the user.

@param authenticationToken A business authentication token obtained by calling UserStore.authenticateToBusiness.

@throws EDAMUserException

INVALID_AUTH "authenticationToken" - if the authentication token is not a business auth token.

Function: NoteStore.getNotebook

Types.Notebook getNotebook(string authenticationToken,
                           Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of the notebook with the provided GUID. The notebook may be active or deleted (but not expunged).

@param guid The GUID of the notebook to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
PERMISSION_DENIED "Notebook" - private notebook, user doesn't own

@throws EDAMNotFoundException

"Notebook.guid" - tag not found, by GUID

Function: NoteStore.getDefaultNotebook

Types.Notebook getDefaultNotebook(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Returns the notebook that should be used to store new notes in the user's account when no other notebooks are specified.

Function: NoteStore.createNotebook

Types.Notebook createNotebook(string authenticationToken,
                              Types.Notebook notebook)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Asks the service to make a notebook with the provided name.

@param notebook The desired fields for the notebook must be provided on this object. The name of the notebook must be set, and either the 'active' or 'defaultNotebook' fields may be set by the client at creation. If a notebook exists in the account with the same name (via case-insensitive compare), this will throw an EDAMUserException.

@return The newly created Notebook. The server-side GUID will be saved in this object's 'guid' field.

@throws EDAMUserException

BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
DATA_CONFLICT "Notebook.name" - name already in use
DATA_CONFLICT "Publishing.uri" - if URI already in use
DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
DATA_REQUIRED "Notebook" - notebook parameter was null
PERMISSION_DENIED "Notebook.defaultNotebook" - if the 'defaultNotebook' field is set to 'true' for a Notebook that is not owned by the user identified by the passed authenticationToken.
LIMIT_REACHED "Notebook" - at max number of notebooks

Function: NoteStore.updateNotebook

i32 updateNotebook(string authenticationToken,
                   Types.Notebook notebook)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Submits notebook changes to the service. The provided data must include the notebook's guid field for identification.

@param notebook The notebook object containing the requested changes.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
DATA_CONFLICT "Notebook.name" - name already in use
DATA_CONFLICT "Publishing.uri" - if URI already in use
DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
DATA_REQUIRED "Notebook" - notebook parameter was null
PERMISSION_DENIED "Notebook.defaultNotebook" - if the 'defaultNotebook' field is set to 'true' for a Notebook that is not owned by the user identified by the passed authenticationToken.

@throws EDAMNotFoundException

"Notebook.guid" - not found, by GUID

Function: NoteStore.expungeNotebook

i32 expungeNotebook(string authenticationToken,
                    Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Permanently removes the notebook from the user's account. After this action, the notebook is no longer available for undeletion, etc. If the notebook contains any Notes, they will be moved to the current default notebook and moved into the trash (i.e. Note.active=false).

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param guid The GUID of the notebook to delete.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
LIMIT_REACHED "Notebook" - trying to expunge the last Notebook
PERMISSION_DENIED "Notebook" - private notebook, user doesn't own

Function: NoteStore.listTags

list<Types.Tag> listTags(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Returns a list of the tags in the account. Evernote does not support the undeletion of tags, so this will only include active tags.

Function: NoteStore.listTagsByNotebook

list<Types.Tag> listTagsByNotebook(string authenticationToken,
                                   Types.Guid notebookGuid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns a list of the tags that are applied to at least one note within the provided notebook. If the notebook is public, the authenticationToken may be ignored.

@param notebookGuid the GUID of the notebook to use to find tags

@throws EDAMNotFoundException

"Notebook.guid" - notebook not found by GUID

Function: NoteStore.getTag

Types.Tag getTag(string authenticationToken,
                 Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of the Tag with the provided GUID.

@param guid The GUID of the tag to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Tag.guid" - if the parameter is missing
PERMISSION_DENIED "Tag" - private Tag, user doesn't own

@throws EDAMNotFoundException

"Tag.guid" - tag not found, by GUID

Function: NoteStore.createTag

Types.Tag createTag(string authenticationToken,
                    Types.Tag tag)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Asks the service to make a tag with a set of information.

@param tag The desired list of fields for the tag are specified in this object. The caller must specify the tag name, and may provide the parentGUID.

@return The newly created Tag. The server-side GUID will be saved in this object.

@throws EDAMUserException

BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
DATA_CONFLICT "Tag.name" - name already in use
LIMIT_REACHED "Tag" - at max number of tags

@throws EDAMNotFoundException

"Tag.parentGuid" - not found, by GUID

Function: NoteStore.updateTag

i32 updateTag(string authenticationToken,
              Types.Tag tag)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Submits tag changes to the service. The provided data must include the tag's guid field for identification. The service will apply updates to the following tag fields: name, parentGuid

@param tag The tag object containing the requested changes.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
DATA_CONFLICT "Tag.name" - name already in use
DATA_CONFLICT "Tag.parentGuid" - can't set parent: circular
PERMISSION_DENIED "Tag" - user doesn't own tag

@throws EDAMNotFoundException

"Tag.guid" - tag not found, by GUID
"Tag.parentGuid" - parent not found, by GUID

Function: NoteStore.untagAll

void untagAll(string authenticationToken,
              Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Removes the provided tag from every note that is currently tagged with this tag. If this operation is successful, the tag will still be in the account, but it will not be tagged on any notes.

This function is not indended for use by full synchronizing clients, since it does not provide enough result information to the client to reconcile the local state without performing a follow-up sync from the service. This is intended for "thin clients" that need to efficiently support this as a UI operation.

@param guid The GUID of the tag to remove from all notes.

@throws EDAMUserException

BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
PERMISSION_DENIED "Tag" - user doesn't own tag

@throws EDAMNotFoundException

"Tag.guid" - tag not found, by GUID

Function: NoteStore.expungeTag

i32 expungeTag(string authenticationToken,
               Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Permanently deletes the tag with the provided GUID, if present.

NOTE: This function is not generally available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param guid The GUID of the tag to delete.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
PERMISSION_DENIED "Tag" - user doesn't own tag

@throws EDAMNotFoundException

"Tag.guid" - tag not found, by GUID

Function: NoteStore.listSearches

list<Types.SavedSearch> listSearches(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Returns a list of the searches in the account. Evernote does not support the undeletion of searches, so this will only include active searches.

Function: NoteStore.getSearch

Types.SavedSearch getSearch(string authenticationToken,
                            Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of the search with the provided GUID.

@param guid The GUID of the search to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "SavedSearch.guid" - if the parameter is missing
PERMISSION_DENIED "SavedSearch" - private Tag, user doesn't own

@throws EDAMNotFoundException

"SavedSearch.guid" - not found, by GUID

Function: NoteStore.createSearch

Types.SavedSearch createSearch(string authenticationToken,
                               Types.SavedSearch search)
    throws Errors.EDAMUserException, Errors.EDAMSystemException

Asks the service to make a saved search with a set of information.

@param search The desired list of fields for the search are specified in this object. The caller must specify the name and query for the search, and may optionally specify a search scope. The SavedSearch.format field is ignored by the service.

@return The newly created SavedSearch. The server-side GUID will be saved in this object.

@throws EDAMUserException

BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
BAD_DATA_FORMAT "SavedSearch.query" - invalid length
DATA_CONFLICT "SavedSearch.name" - name already in use
LIMIT_REACHED "SavedSearch" - at max number of searches

Function: NoteStore.updateSearch

i32 updateSearch(string authenticationToken,
                 Types.SavedSearch search)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Submits search changes to the service. The provided data must include the search's guid field for identification. The service will apply updates to the following search fields: name, query, and scope.

@param search The search object containing the requested changes.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
BAD_DATA_FORMAT "SavedSearch.query" - invalid length
DATA_CONFLICT "SavedSearch.name" - name already in use
PERMISSION_DENIED "SavedSearch" - user doesn't own tag

@throws EDAMNotFoundException

"SavedSearch.guid" - not found, by GUID

Function: NoteStore.expungeSearch

i32 expungeSearch(string authenticationToken,
                  Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Permanently deletes the saved search with the provided GUID, if present.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param guid The GUID of the search to delete.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

BAD_DATA_FORMAT "SavedSearch.guid" - if the guid parameter is empty
PERMISSION_DENIED "SavedSearch" - user doesn't own

@throws EDAMNotFoundException

"SavedSearch.guid" - not found, by GUID

Function: NoteStore.findNoteOffset

i32 findNoteOffset(string authenticationToken,
                   NoteFilter filter,
                   Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Finds the position of a note within a sorted subset of all of the user's notes. This may be useful for thin clients that are displaying a paginated listing of a large account, which need to know where a particular note sits in the list without retrieving all notes first.

@param authenticationToken Must be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.

@param filter The list of criteria that will constrain the notes to be returned.

@param guid The GUID of the note to be retrieved.

@return If the note with the provided GUID is found within the matching note list, this will return the offset of that note within that list (where the first offset is 0). If the note is not found within the set of notes, this will return -1.

@throws EDAMUserException

BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
BAD_DATA_FORMAT "NoteFilter.words" - if search string too long

@throws EDAMNotFoundException

"Notebook.guid" - not found, by GUID
"Note.guid" - not found, by GUID

Function: NoteStore.findNotesMetadata

NotesMetadataList findNotesMetadata(string authenticationToken,
                                    NoteFilter filter,
                                    i32 offset,
                                    i32 maxNotes,
                                    NotesMetadataResultSpec resultSpec)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Used to find the high-level information about a set of the notes from a user's account based on various criteria specified via a NoteFilter object.

Web applications that wish to periodically check for new content in a user's Evernote account should consider using webhooks instead of polling this API. See https://dev.evernote.com/documentation/cloud/chapters/polling_notification.php for more information.

@param authenticationToken Must be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.

@param filter The list of criteria that will constrain the notes to be returned.

@param offset The numeric index of the first note to show within the sorted results. The numbering scheme starts with "0". This can be used for pagination.

@param maxNotes The maximum notes to return in this query. The service will return a set of notes that is no larger than this number, but may return fewer notes if needed. The NoteList.totalNotes field in the return value will indicate whether there are more values available after the returned set. Currently, the service will not return more than 250 notes in a single request, but this number may change in the future.

@param resultSpec This specifies which information should be returned for each matching Note. The fields on this structure can be used to eliminate data that the client doesn't need, which will reduce the time and bandwidth to receive and process the reply.

@return The list of notes that match the criteria. The Notes.sharedNotes field will not be set.

@throws EDAMUserException

BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
BAD_DATA_FORMAT "NoteFilter.words" - if search string too long

@throws EDAMNotFoundException

"Notebook.guid" - not found, by GUID

Function: NoteStore.findNoteCounts

NoteCollectionCounts findNoteCounts(string authenticationToken,
                                    NoteFilter filter,
                                    bool withTrash)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

This function is used to determine how many notes are found for each notebook and tag in the user's account, given a current set of filter parameters that determine the current selection. This function will return a structure that gives the note count for each notebook and tag that has at least one note under the requested filter. Any notebook or tag that has zero notes in the filtered set will not be listed in the reply to this function (so they can be assumed to be 0).

@param authenticationToken Must be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.

@param filter The note selection filter that is currently being applied. The note counts are to be calculated with this filter applied to the total set of notes in the user's account.

@param withTrash If true, then the NoteCollectionCounts.trashCount will be calculated and supplied in the reply. Otherwise, the trash value will be omitted.

@throws EDAMUserException

BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
BAD_DATA_FORMAT "NoteFilter.notebookGuids" - if any are malformed
BAD_DATA_FORMAT "NoteFilter.words" - if search string too long

@throws EDAMNotFoundException

"Notebook.guid" - not found, by GUID

Function: NoteStore.getNoteWithResultSpec

Types.Note getNoteWithResultSpec(string authenticationToken,
                                 Types.Guid guid,
                                 NoteResultSpec resultSpec)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of the note in the service with the provided GUID. The ENML contents of the note will only be provided if the 'withContent' parameter is true. The service will include the meta-data for each resource in the note, but the binary contents of the resources and their recognition data will be omitted. If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string). The applicationData fields are returned as keysOnly.

@param authenticationToken An authentication token that grants the caller access to the requested note.

@param guid The GUID of the note to be retrieved.

@param resultSpec A structure specifying the fields of the note that the caller would like to get.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.getNote

Types.Note getNote(string authenticationToken,
                   Types.Guid guid,
                   bool withContent,
                   bool withResourcesData,
                   bool withResourcesRecognition,
                   bool withResourcesAlternateData)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

DEPRECATED. See getNoteWithResultSpec.

This function is equivalent to getNoteWithResultSpec, with each of the boolean parameters mapping to the equivalent field of a NoteResultSpec. The Note.sharedNotes field is never populated on the returned note. To get a note with its shares, use getNoteWithResultSpec.

Function: NoteStore.getNoteApplicationData

Types.LazyMap getNoteApplicationData(string authenticationToken,
                                     Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Get all of the application data for the note identified by GUID, with values returned within the LazyMap fullMap field. If there are no applicationData entries, then a LazyMap with an empty fullMap will be returned. If your application only needs to fetch its own applicationData entry, use getNoteApplicationDataEntry instead.

Function: NoteStore.getNoteApplicationDataEntry

string getNoteApplicationDataEntry(string authenticationToken,
                                   Types.Guid guid,
                                   string key)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Get the value of a single entry in the applicationData map for the note identified by GUID.

@throws EDAMNotFoundException

"Note.guid" - note not found, by GUID
"NoteAttributes.applicationData.key" - note not found, by key

Function: NoteStore.setNoteApplicationDataEntry

i32 setNoteApplicationDataEntry(string authenticationToken,
                                Types.Guid guid,
                                string key,
                                string value)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Update, or create, an entry in the applicationData map for the note identified by guid.

Function: NoteStore.unsetNoteApplicationDataEntry

i32 unsetNoteApplicationDataEntry(string authenticationToken,
                                  Types.Guid guid,
                                  string key)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Remove an entry identified by 'key' from the applicationData map for the note identified by 'guid'. Silently ignores an unset of a non-existing key.

Function: NoteStore.getNoteContent

string getNoteContent(string authenticationToken,
                      Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns XHTML contents of the note with the provided GUID. If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the note to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.getNoteSearchText

string getNoteSearchText(string authenticationToken,
                         Types.Guid guid,
                         bool noteOnly,
                         bool tokenizeForIndexing)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns a block of the extracted plain text contents of the note with the provided GUID. This text can be indexed for search purposes by a light client that doesn't have capabilities to extract all of the searchable text content from the note and its resources.

If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the note to be retrieved.

@param noteOnly If true, this will only return the text extracted from the ENML contents of the note itself. If false, this will also include the extracted text from any text-bearing resources (PDF, recognized images)

@param tokenizeForIndexing If true, this will break the text into cleanly separated and sanitized tokens. If false, this will return the more raw text extraction, with its original punctuation, capitalization, spacing, etc.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.getResourceSearchText

string getResourceSearchText(string authenticationToken,
                             Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns a block of the extracted plain text contents of the resource with the provided GUID. This text can be indexed for search purposes by a light client that doesn't have capability to extract all of the searchable text content from a resource.

If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the resource to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID

Function: NoteStore.getNoteTagNames

list<string> getNoteTagNames(string authenticationToken,
                             Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns a list of the names of the tags for the note with the provided guid. This can be used with authentication to get the tags for a user's own note, or can be used without valid authentication to retrieve the names of the tags for a note in a public notebook.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.createNote

Types.Note createNote(string authenticationToken,
                      Types.Note note)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Asks the service to make a note with the provided set of information.

@param note A Note object containing the desired fields to be populated on the service.

@return The newly created Note from the service. The server-side GUIDs for the Note and any Resources will be saved in this object.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.title" - invalid length or pattern
BAD_DATA_FORMAT "Note.content" - invalid length for ENML content
BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
DATA_CONFLICT "Note.deleted" - deleted time set on active note
DATA_REQUIRED "Resource.data" - resource data body missing
ENML_VALIDATION "*" - note content doesn't validate against DTD
LIMIT_REACHED "Note" - at max number per account
LIMIT_REACHED "Note.size" - total note size too large
LIMIT_REACHED "Note.resources" - too many resources on Note
LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
LIMIT_REACHED "Resource.data.size" - resource too large
LIMIT_REACHED "NoteAttribute.*" - attribute string too long
LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
PERMISSION_DENIED "Note.notebookGuid" - NB not owned by user
QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one of the specified tags had an invalid length or pattern
LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required new tags would exceed the maximum number per account

@throws EDAMNotFoundException

"Note.notebookGuid" - not found, by GUID

Function: NoteStore.updateNote

Types.Note updateNote(string authenticationToken,
                      Types.Note note)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Submit a set of changes to a note to the service. The provided data must include the note's guid field for identification. The note's title must also be set.

@param note A Note object containing the desired fields to be populated on the service. With the exception of the note's title and guid, fields that are not being changed do not need to be set. If the content is not being modified, note.content should be left unset. If the list of resources is not being modified, note.resources should be left unset.

@return The metadata (no contents) for the Note on the server after the update. The Note.sharedNotes field will not be set.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.title" - invalid length or pattern
BAD_DATA_FORMAT "Note.content" - invalid length for ENML body
BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
DATA_CONFLICT "Note.deleted" - deleted time set on active note
DATA_REQUIRED "Resource.data" - resource data body missing
ENML_VALIDATION "*" - note content doesn't validate against DTD
LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
LIMIT_REACHED "Note.resources" - too many resources on Note
LIMIT_REACHED "Note.size" - total note size too large
LIMIT_REACHED "Resource.data.size" - resource too large
LIMIT_REACHED "NoteAttribute.*" - attribute string too long
LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
PERMISSION_DENIED "Note.notebookGuid" - user doesn't own destination
PERMISSION_DENIED "Note.tags" - user doesn't have permission to modify the note's tags. note.tags must be unset.
PERMISSION_DENIED "Note.attributes" - user doesn't have permission to modify the note's attributes. note.attributes must be unset.
QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one of the specified tags had an invalid length or pattern
LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required new tags would exceed the maximum number per account

@throws EDAMNotFoundException

"Note.guid" - note not found, by GUID
"Note.notebookGuid" - if notebookGuid provided, but not found

Function: NoteStore.deleteNote

i32 deleteNote(string authenticationToken,
               Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Moves the note into the trash. The note may still be undeleted, unless it is expunged. This is equivalent to calling updateNote() after setting Note.active = false

@param guid The GUID of the note to delete.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

PERMISSION_DENIED "Note" - user doesn't have permission to update the note.

@throws EDAMUserException

DATA_CONFLICT "Note.guid" - the note is already deleted

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.expungeNote

i32 expungeNote(string authenticationToken,
                Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Permanently removes a Note, and all of its Resources, from the service.

NOTE: This function is not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param guid The GUID of the note to delete.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

PERMISSION_DENIED "Note" - user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.copyNote

Types.Note copyNote(string authenticationToken,
                    Types.Guid noteGuid,
                    Types.Guid toNotebookGuid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Performs a deep copy of the Note with the provided GUID 'noteGuid' into the Notebook with the provided GUID 'toNotebookGuid'. The caller must be the owner of both the Note and the Notebook. This creates a new Note in the destination Notebook with new content and Resources that match all of the content and Resources from the original Note, but with new GUID identifiers. The original Note is not modified by this operation. The copied note is considered as an "upload" for the purpose of upload transfer limit calculation, so its size is added to the upload count for the owner.

If the original note has been shared and has SharedNote records, the shares are NOT copied.

@param noteGuid The GUID of the Note to copy.

@param toNotebookGuid The GUID of the Notebook that should receive the new Note.

@return The metadata for the new Note that was created. This will include the new GUID for this Note (and any copied Resources), but will not include the content body or the binary bodies of any Resources.

@throws EDAMUserException

LIMIT_REACHED "Note" - at max number per account
PERMISSION_DENIED "Notebook.guid" - destination not owned by user
PERMISSION_DENIED "Note" - user doesn't own
QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota

@throws EDAMNotFoundException

"Notebook.guid" - not found, by GUID

Function: NoteStore.listNoteVersions

list<NoteVersionId> listNoteVersions(string authenticationToken,
                                     Types.Guid noteGuid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns a list of the prior versions of a particular note that are saved within the service. These prior versions are stored to provide a recovery from unintentional removal of content from a note. The identifiers that are returned by this call can be used with getNoteVersion to retrieve the previous note. The identifiers will be listed from the most recent versions to the oldest. This call is only available for notes in Premium accounts. (I.e. access to past versions of Notes is a Premium-only feature.)

@throws EDAMUserException

DATA_REQUIRED "Note.guid" - if GUID is null or empty string.
BAD_DATA_FORMAT "Note.guid" - if GUID is not of correct length.

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID.

Function: NoteStore.getNoteVersion

Types.Note getNoteVersion(string authenticationToken,
                          Types.Guid noteGuid,
                          i32 updateSequenceNum,
                          bool withResourcesData,
                          bool withResourcesRecognition,
                          bool withResourcesAlternateData)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

This can be used to retrieve a previous version of a Note after it has been updated within the service. The caller must identify the note (via its guid) and the version (via the updateSequenceNumber of that version). to find a listing of the stored version USNs for a note, call listNoteVersions. This call is only available for notes in Premium accounts. (I.e. access to past versions of Notes is a Premium-only feature.)

@param noteGuid The GUID of the note to be retrieved.

@param updateSequenceNum The USN of the version of the note that is being retrieved

@param withResourcesData If true, any Resource elements in this Note will include the binary contents of their 'data' field's body.

@param withResourcesRecognition If true, any Resource elements will include the binary contents of the 'recognition' field's body if recognition data is present.

@param withResourcesAlternateData If true, any Resource elements in this Note will include the binary contents of their 'alternateData' fields' body, if an alternate form is present.

@throws EDAMUserException

DATA_REQUIRED "Note.guid" - if GUID is null or empty string.
BAD_DATA_FORMAT "Note.guid" - if GUID is not of correct length.

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID.
"Note.updateSequenceNumber" - the Note doesn't have a version with the corresponding USN.

Function: NoteStore.getResource

Types.Resource getResource(string authenticationToken,
                           Types.Guid guid,
                           bool withData,
                           bool withRecognition,
                           bool withAttributes,
                           bool withAlternateData)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of the resource in the service with the provided GUID. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string). Only the keys for the applicationData will be returned.

@param guid The GUID of the resource to be retrieved.

@param withData If true, the Resource will include the binary contents of the 'data' field's body.

@param withRecognition If true, the Resource will include the binary contents of the 'recognition' field's body if recognition data is present.

@param withAttributes If true, the Resource will include the attributes

@param withAlternateData If true, the Resource will include the binary contents of the 'alternateData' field's body, if an alternate form is present.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID

Function: NoteStore.getResourceApplicationData

Types.LazyMap getResourceApplicationData(string authenticationToken,
                                         Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Get all of the application data for the Resource identified by GUID, with values returned within the LazyMap fullMap field. If there are no applicationData entries, then a LazyMap with an empty fullMap will be returned. If your application only needs to fetch its own applicationData entry, use getResourceApplicationDataEntry instead.

Function: NoteStore.getResourceApplicationDataEntry

string getResourceApplicationDataEntry(string authenticationToken,
                                       Types.Guid guid,
                                       string key)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Get the value of a single entry in the applicationData map for the Resource identified by GUID.

@throws EDAMNotFoundException

"Resource.guid" - Resource not found, by GUID
"ResourceAttributes.applicationData.key" - Resource not found, by key

Function: NoteStore.setResourceApplicationDataEntry

i32 setResourceApplicationDataEntry(string authenticationToken,
                                    Types.Guid guid,
                                    string key,
                                    string value)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Update, or create, an entry in the applicationData map for the Resource identified by guid.

Function: NoteStore.unsetResourceApplicationDataEntry

i32 unsetResourceApplicationDataEntry(string authenticationToken,
                                      Types.Guid guid,
                                      string key)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Remove an entry identified by 'key' from the applicationData map for the Resource identified by 'guid'.

Function: NoteStore.updateResource

i32 updateResource(string authenticationToken,
                   Types.Resource resource)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Submit a set of changes to a resource to the service. This can be used to update the meta-data about the resource, but cannot be used to change the binary contents of the resource (including the length and hash). These cannot be changed directly without creating a new resource and removing the old one via updateNote.

@param resource A Resource object containing the desired fields to be populated on the service. The service will attempt to update the resource with the following fields from the client:

guid: must be provided to identify the resource
mime
width
height
duration
attributes: optional. if present, the set of attributes will be replaced.

@return The Update Sequence Number of the resource after the changes have been applied.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID

Function: NoteStore.getResourceData

string getResourceData(string authenticationToken,
                       Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns binary data of the resource with the provided GUID. For example, if this were an image resource, this would contain the raw bits of the image. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the resource to be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID

Function: NoteStore.getResourceByHash

Types.Resource getResourceByHash(string authenticationToken,
                                 Types.Guid noteGuid,
                                 string contentHash,
                                 bool withData,
                                 bool withRecognition,
                                 bool withAlternateData)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the current state of a resource, referenced by containing note GUID and resource content hash.

@param noteGuid The GUID of the note that holds the resource to be retrieved.

@param contentHash The MD5 checksum of the resource within that note. Note that this is the binary checksum, for example from Resource.data.bodyHash, and not the hex-encoded checksum that is used within an en-media tag in a note body.

@param withData If true, the Resource will include the binary contents of the 'data' field's body.

@param withRecognition If true, the Resource will include the binary contents of the 'recognition' field's body.

@param withAlternateData If true, the Resource will include the binary contents of the 'alternateData' field's body, if an alternate form is present.

@throws EDAMUserException

DATA_REQUIRED "Note.guid" - noteGuid param missing
DATA_REQUIRED "Note.contentHash" - contentHash param missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Note" - not found, by guid
"Resource" - not found, by hash

Function: NoteStore.getResourceRecognition

string getResourceRecognition(string authenticationToken,
                              Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the binary contents of the recognition index for the resource with the provided GUID. If the caller asks about a resource that has no recognition data, this will throw EDAMNotFoundException. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the resource whose recognition data should be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID
"Resource.recognition" - resource has no recognition

Function: NoteStore.getResourceAlternateData

string getResourceAlternateData(string authenticationToken,
                                Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

If the Resource with the provided GUID has an alternate data representation (indicated via the Resource.alternateData field), then this request can be used to retrieve the binary contents of that alternate data file. If the caller asks about a resource that has no alternate data form, this will throw EDAMNotFoundException.

@param guid The GUID of the resource whose recognition data should be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID
"Resource.alternateData" - resource has no recognition

Function: NoteStore.getResourceAttributes

Types.ResourceAttributes getResourceAttributes(string authenticationToken,
                                               Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Returns the set of attributes for the Resource with the provided GUID. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

@param guid The GUID of the resource whose attributes should be retrieved.

@throws EDAMUserException

BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
PERMISSION_DENIED "Resource" - private resource, user doesn't own

@throws EDAMNotFoundException

"Resource.guid" - not found, by GUID

Function: NoteStore.getPublicNotebook

Types.Notebook getPublicNotebook(Types.UserID userId,
                                 string publicUri)
    throws Errors.EDAMSystemException, Errors.EDAMNotFoundException

Looks for a user account with the provided userId on this NoteStore shard and determines whether that account contains a public notebook with the given URI. If the account is not found, or no public notebook exists with this URI, this will throw an EDAMNotFoundException, otherwise this will return the information for that Notebook.

If a notebook is visible on the web with a full URL like https://www.evernote.com/pub/sethdemo/api Then 'sethdemo' is the username that can be used to look up the userId, and 'api' is the publicUri.

@param userId The numeric identifier for the user who owns the public notebook. To find this value based on a username string, you can invoke UserStore.getPublicUserInfo

@param publicUri The uri string for the public notebook, from Notebook.publishing.uri.

@throws EDAMNotFoundException

"Publishing.uri" - not found, by URI

@throws EDAMSystemException

TAKEN_DOWN "PublicNotebook" - The specified public notebook is taken down (for all requesters).
TAKEN_DOWN "Country" - The specified public notebook is taken down for the requester because of an IP-based country lookup.

Function: NoteStore.shareNotebook

Types.SharedNotebook shareNotebook(string authenticationToken,
                                   Types.SharedNotebook sharedNotebook,
                                   string message)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

@Deprecated for first-party clients. See createOrUpdateNotebookShares.

Share a notebook with an email address, and optionally to a specific recipient. If an existing SharedNotebook associated with sharedNotebook.notebookGuid is found by recipientUsername or email, then the values of sharedNotebook will be used to update the existing record, else a new record will be created.

If recipientUsername is set and there is already a SharedNotebook for that Notebook with that recipientUsername and the privileges on the existing notebook are lower, than on this one, this will update the privileges and sharerUserId. If there isn't an existing SharedNotebook for recipientUsername, this will create and return a shared notebook for that email and recipientUsername. If recipientUsername is not set and there already is a SharedNotebook for a Notebook for that email address and the privileges on the existing SharedNotebook are lower than on this one, this will update the privileges and sharerUserId, and return the updated SharedNotebook. Otherwise, this will create and return a SharedNotebook for the email address.

If the authenticationToken is a Business auth token, recipientUsername is set and the recipient is in the same business as the business auth token, this method will also auto-join the business user to the SharedNotebook - that is it will set serviceJoined on the SharedNotebook and create a LinkedNotebook on the recipient's account pointing to the SharedNotebook. The LinkedNotebook creation happens out-of-band, so there will be a delay on the order of half a minute between the SharedNotebook and LinkedNotebook creation.

Also handles sending an email to the email addresses: if a SharedNotebook is being created, this will send the shared notebook invite email, which contains a link to join the notebook.
If the notebook is being auto-joined (usually for sharing within an Evernote Business account) an email with that information is sent to the recipient.

@param authenticationToken Must be an authentication token from the owner or a shared notebook authentication token or business authentication token with sufficient permissions to change invitations for a notebook.

@param sharedNotebook A shared notebook object populated with the email address of the share recipient, the notebook guid and the access permissions. All other attributes of the shared object are ignored. The SharedNotebook.allowPreview field must be explicitly set with either a true or false value.

@param message The sharer-defined message to put in the email sent out.

@return The fully populated SharedNotebook object including the server assigned globalId which can both be used to uniquely identify the SharedNotebook.

@throws EDAMUserException

BAD_DATA_FORMAT "SharedNotebook.email" - if the email was not valid
DATA_REQUIRED "SharedNotebook.privilege" - if the SharedNotebook.privilegeLevel was not set.
BAD_DATA_FORMAT "SharedNotebook.requireLogin" - if requireLogin was set. requireLogin is deprecated.
BAD_DATA_FORMAT "SharedNotebook.privilegeLevel" - if the SharedNotebook.privilegeLevel field was unset or set to GROUP.
PERMISSION_DENIED "user" - if the email address on the authenticationToken's owner's account is not confirmed.
PERMISSION_DENIED "SharedNotebook.recipientSettings" - if recipientSettings is set in the sharedNotebook. Only the recipient can set these values via the setSharedNotebookRecipientSettings method.
EDAMErrorCode.LIMIT_REACHED "SharedNotebook" - The notebook already has EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX shares.

@throws EDAMNotFoundException

Notebook.guid - if the notebookGuid is not a valid GUID for the user.

Function: NoteStore.createOrUpdateNotebookShares

CreateOrUpdateNotebookSharesResult createOrUpdateNotebookShares(string authenticationToken,
                                                                NotebookShareTemplate shareTemplate)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException, Errors.EDAMInvalidContactsException

Share a notebook by a messaging thread ID or a list of contacts. This function is intended to be used in conjunction with Evernote messaging, and as such does not notify the recipient that a notebook has been shared with them.

Sharing with a subset of participants on a thread is accomplished by specifying both a thread ID and a list of contacts. This ensures that even if those contacts are on the thread under a deactivated identity, the correct user (the one who has the given contact on the thread) receives the share.

@param authenticationToken An authentication token that grants the caller permission to share the notebook. This should be an owner token if the notebook is owned by the caller. If the notebook is a business notebook to which the caller has full access, this should be their business authentication token. If the notebook is a shared (non-business) notebook to which the caller has full access, this should be the shared notebook authentication token returned by NoteStore.authenticateToNotebook.

@param shareTemplate Specifies the GUID of the notebook to be shared, the privilege at which the notebook should be shared, and the recipient information.

@return A structure containing the USN of the Notebook after the change and a list of created or updated SharedNotebooks.

@throws EDAMUserException

DATA_REQUIRED "Notebook.guid" - if no notebook GUID was specified
BAD_DATA_FORMAT "Notebook.guid" - if shareTemplate.notebookGuid is not a valid GUID
DATA_REQUIRED "shareTemplate" - if the shareTemplate parameter was missing
DATA_REQUIRED "NotebookShareTemplate.privilege" - if no privilege was specified
DATA_CONFLICT "NotebookShareTemplate.privilege" - if the specified privilege is not allowed.
DATA_REQUIRED "NotebookShareTemplate.recipients" - if no recipients were specified, either by thread ID or as a list of contacts
LIMIT_REACHED "SharedNotebook" - if the notebook has reached its maximum number of shares

@throws EDAMInvalidContactsException

"NotebookShareTemplate.recipients" - if one or more of the recipients specified in shareTemplate.recipients was not syntactically valid, or if attempting to share a notebook with an Evernote identity that the sharer does not have a connection to. The exception will specify which recipients were invalid.

@throws EDAMNotFoundException

"Notebook.guid" - if no notebook with the specified GUID was found
"NotebookShareTemplate.recipientThreadId" - if the recipient thread ID was specified, but no thread with that ID exists

Function: NoteStore.updateSharedNotebook

i32 updateSharedNotebook(string authenticationToken,
                         Types.SharedNotebook sharedNotebook)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

@Deprecated See createOrUpdateNotebookShares and manageNotebookShares.

Function: NoteStore.setNotebookRecipientSettings

Types.Notebook setNotebookRecipientSettings(string authenticationToken,
                                            string notebookGuid,
                                            Types.NotebookRecipientSettings recipientSettings)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Set values for the recipient settings associated with a notebook share. Only the recipient of the share can update their recipient settings.

If you do not wish to, or cannot, change one of the recipient settings fields, you must leave that field unset in recipientSettings. This method will skip that field for updates and attempt to leave the existing value as it is.

If recipientSettings.inMyList is false, both reminderNotifyInApp and reminderNotifyEmail will be either left as null or converted to false (if currently true).

@param authenticationToken The owner authentication token for the recipient of the share.

@return recipient settings may differ from what was requested. Clients should update their state based on this return value.

@throws EDAMNotFoundException

Notebook.guid - Thrown if the service does not have a notebook record with the notebookGuid on the given shard.
Publishing.publishState - Thrown if the business notebook is not shared with the user and is also not published to their business.

@throws EDAMUserException

PEMISSION_DENIED "authenticationToken" - If the owner of the given token is not allowed to set recipient settings on the specified notebook.
DATA_CONFLICT "recipientSettings.reminderNotifyEmail" - Setting reminderNotifyEmail is allowed only for notebooks which belong to the same business as the user.
DATA_CONFLICT "recipientSettings.inMyList" - If the request is setting inMyList to false and any of reminder* settings to true.

Function: NoteStore.listSharedNotebooks

list<Types.SharedNotebook> listSharedNotebooks(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Lists the collection of shared notebooks for all notebooks in the users account.

@return The list of all SharedNotebooks for the user

Function: NoteStore.createLinkedNotebook

Types.LinkedNotebook createLinkedNotebook(string authenticationToken,
                                          Types.LinkedNotebook linkedNotebook)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Asks the service to make a linked notebook with the provided name, username of the owner and identifiers provided. A linked notebook can be either a link to a public notebook or to a private shared notebook.

@param linkedNotebook The desired fields for the linked notebook must be provided on this object. The name of the linked notebook must be set. Either a username uri or a shard id and share key must be provided otherwise a EDAMUserException is thrown.

@return The newly created LinkedNotebook. The server-side id will be saved in this object's 'id' field.

@throws EDAMUserException

DATA_REQUIRED "LinkedNotebook.shareName" - missing shareName
BAD_DATA_FORMAT "LinkedNotebook.name" - invalid shareName length or pattern
BAD_DATA_FORMAT "LinkedNotebook.username" - bad username format
BAD_DATA_FORMAT "LinkedNotebook.uri" - if public notebook set but bad uri
DATA_REQUIRED "LinkedNotebook.shardId" - if private notebook but shard id not provided
BAD_DATA_FORMAT "LinkedNotebook.stack" - invalid stack name length or pattern

@throws EDAMSystemException

BAD_DATA_FORMAT "LinkedNotebook.sharedNotebookGlobalId" - if a bad global identifer was set on a private notebook

Function: NoteStore.updateLinkedNotebook

i32 updateLinkedNotebook(string authenticationToken,
                         Types.LinkedNotebook linkedNotebook)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

@param linkedNotebook Updates the name of a linked notebook.

@return The Update Sequence Number for this change within the account.

@throws EDAMUserException

DATA_REQUIRED "LinkedNotebook.shareName" - missing shareName
BAD_DATA_FORMAT "LinkedNotebook.shareName" - invalid shareName length or pattern
BAD_DATA_FORMAT "LinkedNotebook.stack" - invalid stack name length or pattern

Function: NoteStore.listLinkedNotebooks

list<Types.LinkedNotebook> listLinkedNotebooks(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Returns a list of linked notebooks

Function: NoteStore.expungeLinkedNotebook

i32 expungeLinkedNotebook(string authenticationToken,
                          Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Permanently expunges the linked notebook from the account.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param guid The LinkedNotebook.guid field of the LinkedNotebook to permanently remove from the account.

Function: NoteStore.authenticateToSharedNotebook

UserStore.AuthenticationResult authenticateToSharedNotebook(string shareKeyOrGlobalId,
                                                            string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Asks the service to produce an authentication token that can be used to access the contents of a shared notebook from someone else's account. This authenticationToken can be used with the various other NoteStore calls to find and retrieve notes, and if the permissions in the shared notebook are sufficient, to make changes to the contents of the notebook.

@param shareKeyOrGlobalId May be one of the following:

A share key for a shared notebook that was granted to some recipient Must be used if you are joining a notebook unless it was shared via createOrUpdateNotebookShares. Share keys are delivered out-of-band and are generally not available to clients. For security reasons, share keys may be invalidated at the discretion of the service.
The shared notebook global identifier. May be used to access a notebook that is already joined.
The Notebook GUID. May be used to access a notebook that was already joined, or to access a notebook that was shared with the recipient via createOrUpdateNotebookShares.

@param authenticationToken If a non-empty string is provided, this is the full user-based authentication token that identifies the user who is currently logged in and trying to access the shared notebook. If this string is empty, the service will attempt to authenticate to the shared notebook without any logged in user.

@throws EDAMSystemException

BAD_DATA_FORMAT "shareKey" - invalid shareKey string
INVALID_AUTH "shareKey" - bad signature on shareKey string

@throws EDAMNotFoundException

"SharedNotebook.id" - the shared notebook no longer exists

@throws EDAMUserException

DATA_REQUIRED "authenticationToken" - the share requires login, and no valid authentication token was provided.
PERMISSION_DENIED "SharedNotebook.username" - share requires login, and another username has already been bound to this notebook.

Function: NoteStore.getSharedNotebookByAuth

Types.SharedNotebook getSharedNotebookByAuth(string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

This function is used to retrieve extended information about a shared notebook by a guest who has already authenticated to access that notebook. This requires an 'authenticationToken' parameter which should be the resut of a call to authenticateToSharedNotebook(...). I.e. this is the token that gives access to the particular shared notebook in someone else's account -- it's not the authenticationToken for the owner of the notebook itself.

@param authenticationToken Should be the authentication token retrieved from the reply of authenticateToSharedNotebook(), proving access to a particular shared notebook.

@throws EDAMUserException

PERMISSION_DENIED "authenticationToken" - authentication token doesn't correspond to a valid shared notebook

@throws EDAMNotFoundException

"SharedNotebook.id" - the shared notebook no longer exists

Function: NoteStore.emailNote

void emailNote(string authenticationToken,
               NoteEmailParameters parameters)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Attempts to send a single note to one or more email recipients.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

@param authenticationToken The note will be sent as the user logged in via this token, using that user's registered email address. If the authenticated user doesn't have permission to read that note, the emailing will fail.

@param parameters The note must be specified either by GUID (in which case it will be sent using the existing data in the service), or else the full Note must be passed to this call. This also specifies the additional email fields that will be used in the email.

@throws EDAMUserException

LIMIT_REACHED "NoteEmailParameters.toAddresses" - The email can't be sent because this would exceed the user's daily email limit.
BAD_DATA_FORMAT "(email address)" - email address malformed
DATA_REQUIRED "NoteEmailParameters.toAddresses" - if there are no To: or Cc: addresses provided.
DATA_REQUIRED "Note.title" - if the caller provides a Note parameter with no title
DATA_REQUIRED "Note.content" - if the caller provides a Note parameter with no content
ENML_VALIDATION "*" - note content doesn't validate against DTD
DATA_REQUIRED "NoteEmailParameters.note" - if no guid or note provided
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.shareNote

string shareNote(string authenticationToken,
                 Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

If this note is not already shared publicly (via its own direct URL), then this will start sharing that note. This will return the secret "Note Key" for this note that can currently be used in conjunction with the Note's GUID to gain direct read-only access to the Note. If the note is already shared, then this won't make any changes to the note, and the existing "Note Key" will be returned. The only way to change the Note Key for an existing note is to stopSharingNote first, and then call this function.

@param guid The GUID of the note to be shared.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.stopSharingNote

void stopSharingNote(string authenticationToken,
                     Types.Guid guid)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

If this note is shared publicly then this will stop sharing that note and invalidate its "Note Key", so any existing URLs to access that Note will stop working.

If the Note is not shared, then this function will do nothing.

This function does not remove invididual shares for the note. To remove individual shares, see stopSharingNoteWithRecipients.

@param guid The GUID of the note to be un-shared.

@throws EDAMUserException

BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
PERMISSION_DENIED "Note" - private note, user doesn't own

@throws EDAMNotFoundException

"Note.guid" - not found, by GUID

Function: NoteStore.authenticateToSharedNote

UserStore.AuthenticationResult authenticateToSharedNote(string guid,
                                                        string noteKey,
                                                        string authenticationToken)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Asks the service to produce an authentication token that can be used to access the contents of a single Note which was individually shared from someone's account. This authenticationToken can be used with the various other NoteStore calls to find and retrieve the Note and its directly-referenced children.

@param guid The GUID identifying this Note on this shard.

@param noteKey The 'noteKey' identifier from the Note that was originally created via a call to shareNote() and then given to a recipient to access.

@param authenticationToken An optional authenticationToken that identifies the user accessing the shared note. This parameter may be required to access some shared notes.

@throws EDAMUserException

PERMISSION_DENIED "Note" - the Note with that GUID is either not shared, or the noteKey doesn't match the current key for this note
PERMISSION_DENIED "authenticationToken" - an authentication token is required to access this Note, but either no authentication token or a "non-owner" authentication token was provided.

@throws EDAMNotFoundException

"guid" - the note with that GUID is not found

@throws EDAMSystemException

TAKEN_DOWN "Note" - The specified shared note is taken down (for all requesters).
TAKEN_DOWN "Country" - The specified shared note is taken down for the requester because of an IP-based country lookup.

Function: NoteStore.findRelated

RelatedResult findRelated(string authenticationToken,
                          RelatedQuery query,
                          RelatedResultSpec resultSpec)
    throws Errors.EDAMUserException, Errors.EDAMSystemException, Errors.EDAMNotFoundException

Identify related entities on the service, such as notes, notebooks, tags and users in a business related to notes or content.

@param query The information about which we are finding related entities.

@param resultSpec Allows the client to indicate the type and quantity of information to be returned, allowing a saving of time and bandwidth.

@return The result of the query, with information considered to likely be relevantly related to the information described by the query.

@throws EDAMUserException

BAD_DATA_FORMAT "RelatedQuery.plainText" - If you provided a a zero-length plain text value.
BAD_DATA_FORMAT "RelatedQuery.noteGuid" - If you provided an invalid Note GUID, that is, one that does not match the constraints defined by EDAM_GUID_LEN_MIN, EDAM_GUID_LEN_MAX, EDAM_GUID_REGEX.
BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
PERMISSION_DENIED "Note" - If the caller does not have access to the note identified by RelatedQuery.noteGuid.
PERMISSION_DENIED "authenticationToken" - If the caller has requested to findExperts in the context of a non business user (i.e. The authenticationToken is not a business auth token).
DATA_REQUIRED "RelatedResultSpec" - If you did not not set any values in the result spec.

@throws EDAMNotFoundException

"RelatedQuery.noteGuid" - the note with that GUID is not found, if that field has been set in the query.

Function: NoteStore.updateNoteIfUsnMatches

UpdateNoteIfUsnMatchesResult updateNoteIfUsnMatches(string authenticationToken,
                                                    Types.Note note)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Perform the same operation as updateNote() would provided that the update sequence number on the parameter Note object matches the current update sequence number that the service has for the note. If they do not match, then no update is performed and the return value will have the current server state in the note field and updated will be false. If the update sequence numbers between the client and server do match, then the note will be updated and the note field of the return value will be returned as it would be for the updateNote method. This method allows you to check for an update to the note on the service, by another client instance, from when you obtained the note state as a baseline for your edits and the time when you wish to save your edits. If your client can merge the conflict, you can avoid overwriting changes that were saved to the service by the other client.

See the updateNote method for information on the exceptions and parameters for this method. The only difference is that you must have an update sequence number defined on the note parameter (equal to the USN of the note as synched to the client), and the following additional exceptions might be thrown.

@throws EDAMUserException

DATA_REQUIRED "Note.updateSequenceNum" - If the update sequence number was not provided. This includes a value that is set as 0.
BAD_DATA_FORMAT "Note.updateSequenceNum" - If the note has an update sequence number that is larger than the current server value, which should not happen if your client is working correctly.

Function: NoteStore.manageNotebookShares

ManageNotebookSharesResult manageNotebookShares(string authenticationToken,
                                                ManageNotebookSharesParameters parameters)
    throws Errors.EDAMUserException, Errors.EDAMNotFoundException, Errors.EDAMSystemException

Manage invitations and memberships associated with a given notebook.

Note: Beta method! This method is currently intended for limited use by Evernote clients that have discussed using this routine with the platform team.

@param parameters A structure containing all parameters for the updates. See the structure documentation for details.

@throws EDAMUserException

EDAMErrorCode.LIMIT_REACHED "SharedNotebook" - Trying to share a notebook while the notebook already has EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX shares.

`RECEIVE_REMINDER_EMAIL`	`1`
`TIMEZONE`	`2`

`READ_NOTEBOOK`	`0`
`READ_NOTEBOOK_PLUS_ACTIVITY`	`10`
`MODIFY_NOTEBOOK_PLUS_ACTIVITY`	`20`
`FULL_ACCESS`	`30`

Thrift module: NoteStore

Enumerations

Enumeration: UserSetting

Enumeration: ShareRelationshipPrivilegeLevel

Data structures

Struct: SyncState

Struct: SyncChunk

Struct: SyncChunkFilter

Struct: NoteFilter

Struct: NoteList

Struct: NoteMetadata

Struct: NotesMetadataList

Struct: NotesMetadataResultSpec

Struct: NoteCollectionCounts

Struct: NoteResultSpec

Struct: NoteEmailParameters

Struct: NoteVersionId

Struct: RelatedQuery

Struct: RelatedResult

Struct: RelatedResultSpec

Struct: UpdateNoteIfUsnMatchesResult

Struct: ShareRelationshipRestrictions

Struct: InvitationShareRelationship

Struct: MemberShareRelationship

Struct: ShareRelationships

Struct: ManageNotebookSharesParameters

Struct: ManageNotebookSharesError

Struct: ManageNotebookSharesResult

Struct: SharedNoteTemplate

Struct: NotebookShareTemplate

Struct: CreateOrUpdateNotebookSharesResult

Struct: NoteShareRelationshipRestrictions

Struct: NoteMemberShareRelationship

Struct: NoteInvitationShareRelationship

Struct: NoteShareRelationships

Struct: ManageNoteSharesParameters

Struct: ManageNoteSharesError

Struct: ManageNoteSharesResult

Services

Service: NoteStore

Function: NoteStore.getSyncState

Function: NoteStore.getFilteredSyncChunk

Function: NoteStore.getLinkedNotebookSyncState

Function: NoteStore.getLinkedNotebookSyncChunk

Function: NoteStore.listNotebooks

Function: NoteStore.listAccessibleBusinessNotebooks

Function: NoteStore.getNotebook

Function: NoteStore.getDefaultNotebook

Function: NoteStore.createNotebook

Function: NoteStore.updateNotebook

Function: NoteStore.expungeNotebook

Function: NoteStore.listTags

Function: NoteStore.listTagsByNotebook

Function: NoteStore.getTag

Function: NoteStore.createTag

Function: NoteStore.updateTag

Function: NoteStore.untagAll

Function: NoteStore.expungeTag

Function: NoteStore.listSearches

Function: NoteStore.getSearch

Function: NoteStore.createSearch

Function: NoteStore.updateSearch

Function: NoteStore.expungeSearch

Function: NoteStore.findNoteOffset

Function: NoteStore.findNotesMetadata

Function: NoteStore.findNoteCounts

Function: NoteStore.getNoteWithResultSpec

Function: NoteStore.getNote

Function: NoteStore.getNoteApplicationData

Function: NoteStore.getNoteApplicationDataEntry

Function: NoteStore.setNoteApplicationDataEntry

Function: NoteStore.unsetNoteApplicationDataEntry

Function: NoteStore.getNoteContent

Function: NoteStore.getNoteSearchText

Function: NoteStore.getResourceSearchText

Function: NoteStore.getNoteTagNames

Function: NoteStore.createNote

Function: NoteStore.updateNote

Function: NoteStore.deleteNote

Function: NoteStore.expungeNote