RECEIVE_REMINDER_EMAIL | 1 |
TIMEZONE | 2 |
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 |
Field | Type |
---|---|
currentTime | Types.Timestamp |
fullSyncBefore | Types.Timestamp |
updateCount | i32 |
uploaded | i64 |
userLastUpdated | Types.Timestamp |
userMaxMessageEventId | Types.MessageEventID |
Field | Type |
---|---|
currentTime | Types.Timestamp |
chunkHighUSN | i32 |
updateCount | i32 |
notes | list< |
notebooks | list< |
tags | list< |
searches | list< |
resources | list< |
expungedNotes | list< |
expungedNotebooks | list< |
expungedTags | list< |
expungedSearches | list< |
linkedNotebooks | list< |
expungedLinkedNotebooks | list< |
The server always gives SyncChunks using an ascending series of Update Sequence Numbers (USNs).
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< |
Field | Type |
---|---|
order | i32 |
ascending | bool |
words | string |
notebookGuid | Types.Guid |
tagGuids | list< |
timeZone | string |
inactive | bool |
emphasized | string |
includeAllReadableNotebooks | bool |
Field | Type |
---|---|
startIndex | i32 |
totalNotes | i32 |
notes | list< |
stoppedWords | list< |
searchedWords | list< |
updateCount | i32 |
Field | Type |
---|---|
guid | Types.Guid |
title | string |
contentLength | i32 |
created | Types.Timestamp |
updated | Types.Timestamp |
deleted | Types.Timestamp |
updateSequenceNum | i32 |
notebookGuid | string |
tagGuids | list< |
attributes | Types.NoteAttributes |
largestResourceMime | string |
largestResourceSize | i32 |
Field | Type |
---|---|
startIndex | i32 |
totalNotes | i32 |
notes | list< |
stoppedWords | list< |
searchedWords | list< |
updateCount | i32 |
Field | Type |
---|---|
includeTitle | bool |
includeContentLength | bool |
includeCreated | bool |
includeUpdated | bool |
includeDeleted | bool |
includeUpdateSequenceNum | bool |
includeNotebookGuid | bool |
includeTagGuids | bool |
includeAttributes | bool |
includeLargestResourceMime | bool |
includeLargestResourceSize | bool |
Field | Type |
---|---|
notebookCounts | map< |
tagCounts | map< |
trashCount | i32 |
Field | Type |
---|---|
includeContent | bool |
includeResourcesData | bool |
includeResourcesRecognition | bool |
includeResourcesAlternateData | bool |
includeSharedNotes | bool |
includeNoteAppDataValues | bool |
includeResourceAppDataValues | bool |
includeAccountLimits | bool |
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.
Field | Type |
---|---|
guid | string |
note | Types.Note |
toAddresses | list< |
ccAddresses | list< |
subject | string |
message | string |
Field | Type |
---|---|
updateSequenceNum | i32 |
updated | Types.Timestamp |
saved | Types.Timestamp |
title | string |
lastEditorId | Types.UserID |
Field | Type |
---|---|
noteGuid | string |
plainText | string |
filter | NoteFilter |
referenceUri | string |
context | string |
cacheKey | string |
You must specify either noteGuid or plainText, but not both. filter and referenceUri are optional.
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.
Field | Type |
---|---|
notes | list< |
notebooks | list< |
tags | list< |
containingNotebooks | list< |
debugInfo | string |
experts | list< |
relatedContent | list< |
cacheKey | string |
cacheExpires | i32 |
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.
includeDebugInfo
in RelatedResultSpec is set to
true
, this field may contain debug information
if the service decides to do so.
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.
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.
Field | Type |
---|---|
maxNotes | i32 |
maxNotebooks | i32 |
maxTags | i32 |
writableNotebooksOnly | bool |
includeContainingNotebooks | bool |
includeDebugInfo | bool |
maxExperts | i32 |
maxRelatedContent | i32 |
relatedContentTypes | set< |
true
, return the containingNotebooks field
in the RelatedResult, which will contain the list of notebooks to
to which the returned related notes belong.
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.
Field | Type |
---|---|
note | Types.Note |
updated | bool |
Field | Type |
---|---|
noSetReadOnly | bool |
noSetReadPlusActivity | bool |
noSetModify | bool |
noSetFullAccess | bool |
Field | Type |
---|---|
displayName | string |
recipientUserIdentity | Types.UserIdentity |
privilege | ShareRelationshipPrivilegeLevel |
sharerUserId | Types.UserID |
Field | Type |
---|---|
displayName | string |
recipientUserId | Types.UserID |
bestPrivilege | ShareRelationshipPrivilegeLevel |
individualPrivilege | ShareRelationshipPrivilegeLevel |
restrictions | ShareRelationshipRestrictions |
sharerUserId | Types.UserID |
Field | Type |
---|---|
invitations | list< |
memberships | list< |
invitationRestrictions | ShareRelationshipRestrictions |
Field | Type |
---|---|
notebookGuid | string |
inviteMessage | string |
membershipsToUpdate | list< |
invitationsToCreateOrUpdate | list< |
unshares | list< |
Field | Type |
---|---|
userIdentity | Types.UserIdentity |
userException | Errors.EDAMUserException |
notFoundException | Errors.EDAMNotFoundException |
Field | Type |
---|---|
errors | list< |
Field | Type |
---|---|
noteGuid | Types.Guid |
recipientThreadId | Types.MessageThreadID |
recipientContacts | list< |
privilege | Types.SharedNotePrivilegeLevel |
Field | Type |
---|---|
notebookGuid | Types.Guid |
recipientThreadId | Types.MessageThreadID |
recipientContacts | list< |
privilege | Types.SharedNotebookPrivilegeLevel |
Field | Type |
---|---|
updateSequenceNum | i32 |
matchingShares | list< |
Field | Type |
---|---|
noSetReadNote | bool |
noSetModifyNote | bool |
noSetFullAccess | bool |
Field | Type |
---|---|
displayName | string |
recipientUserId | Types.UserID |
privilege | Types.SharedNotePrivilegeLevel |
restrictions | NoteShareRelationshipRestrictions |
sharerUserId | Types.UserID |
Field | Type |
---|---|
displayName | string |
recipientIdentityId | Types.IdentityID |
privilege | Types.SharedNotePrivilegeLevel |
sharerUserId | Types.UserID |
Field | Type |
---|---|
invitations | list< |
memberships | list< |
invitationRestrictions | NoteShareRelationshipRestrictions |
Field | Type |
---|---|
noteGuid | string |
membershipsToUpdate | list< |
invitationsToUpdate | list< |
membershipsToUnshare | list< |
invitationsToUnshare | list< |
The only field of an existing membership or invitation that can be updated by this function is the share privilege.
Field | Type |
---|---|
identityID | Types.IdentityID |
userID | Types.UserID |
userException | Errors.EDAMUserException |
notFoundException | Errors.EDAMNotFoundException |
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.
Field | Type |
---|---|
errors | list< |
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:
Asks the NoteStore to provide information about the status of the user account corresponding to the provided authentication token.SyncState
getSyncState(string
authenticationToken) throwsErrors.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.SyncChunk
getFilteredSyncChunk(string
authenticationToken,i32
afterUSN,i32
maxEntries,SyncChunkFilter
filter) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
@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 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.
@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
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.SyncState
getLinkedNotebookSyncState(string
authenticationToken,Types.LinkedNotebook
linkedNotebook) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws EDAMNotFoundException
@throws SystemException
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.SyncChunk
getLinkedNotebookSyncChunk(string
authenticationToken,Types.LinkedNotebook
linkedNotebook,i32
afterUSN,i32
maxEntries,bool
fullSyncOnly) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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. This must contain the valid fields for either a shared notebook (e.g. shareKey) or a public notebook (e.g. username, uri)
@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 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
@throws EDAMNotFoundException
Returns a list of all of the notebooks in the account.list<
listNotebooks(Types.Notebook
>string
authenticationToken) throwsErrors.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.list<
listAccessibleBusinessNotebooks(Types.Notebook
>string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
@param authenticationToken A business authentication token obtained by calling UserStore.authenticateToBusiness.
@throws EDAMUserException
Returns the current state of the notebook with the provided GUID. The notebook may be active or deleted (but not expunged).Types.Notebook
getNotebook(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the notebook to be retrieved.
@throws EDAMUserException
@throws EDAMNotFoundException
Returns the notebook that should be used to store new notes in the user's account when no other notebooks are specified.Types.Notebook
getDefaultNotebook(string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
Asks the service to make a notebook with the provided name.Types.Notebook
createNotebook(string
authenticationToken,Types.Notebook
notebook) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
@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
Submits notebook changes to the service. The provided data must include the notebook's guid field for identification.i32
updateNotebook(string
authenticationToken,Types.Notebook
notebook) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param notebook The notebook object containing the requested changes.
@return The Update Sequence Number for this change within the account.
@throws EDAMUserException
@throws 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).i32
expungeNotebook(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
Returns a list of the tags in the account. Evernote does not support the undeletion of tags, so this will only include active tags.list<
listTags(Types.Tag
>string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
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.list<
listTagsByNotebook(Types.Tag
>string
authenticationToken,Types.Guid
notebookGuid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param notebookGuid the GUID of the notebook to use to find tags
@throws EDAMNotFoundException
Returns the current state of the Tag with the provided GUID.Types.Tag
getTag(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the tag to be retrieved.
@throws EDAMUserException
@throws EDAMNotFoundException
Asks the service to make a tag with a set of information.Types.Tag
createTag(string
authenticationToken,Types.Tag
tag) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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, parentGuidi32
updateTag(string
authenticationToken,Types.Tag
tag) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param tag The tag object containing the requested changes.
@return The Update Sequence Number for this change within the account.
@throws EDAMUserException
@throws 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.void
untagAll(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws EDAMNotFoundException
Permanently deletes the tag with the provided GUID, if present.i32
expungeTag(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws EDAMNotFoundException
Returns a list of the searches in the account. Evernote does not support the undeletion of searches, so this will only include active searches.list<
listSearches(Types.SavedSearch
>string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
Returns the current state of the search with the provided GUID.Types.SavedSearch
getSearch(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the search to be retrieved.
@throws EDAMUserException
@throws EDAMNotFoundException
Asks the service to make a saved search with a set of information.Types.SavedSearch
createSearch(string
authenticationToken,Types.SavedSearch
search) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
@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
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.i32
updateSearch(string
authenticationToken,Types.SavedSearch
search) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param search The search object containing the requested changes.
@return The Update Sequence Number for this change within the account.
@throws EDAMUserException
@throws EDAMNotFoundException
Permanently deletes the saved search with the provided GUID, if present.i32
expungeSearch(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws 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.i32
findNoteOffset(string
authenticationToken,NoteFilter
filter,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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.NotesMetadataList
findNotesMetadata(string
authenticationToken,NoteFilter
filter,i32
offset,i32
maxNotes,NotesMetadataResultSpec
resultSpec) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws 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).NoteCollectionCounts
findNoteCounts(string
authenticationToken,NoteFilter
filter,bool
withTrash) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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.Types.Note
getNoteWithResultSpec(string
authenticationToken,Types.Guid
guid,NoteResultSpec
resultSpec) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws EDAMNotFoundException
DEPRECATED. See getNoteWithResultSpec.Types.Note
getNote(string
authenticationToken,Types.Guid
guid,bool
withContent,bool
withResourcesData,bool
withResourcesRecognition,bool
withResourcesAlternateData) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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.
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.Types.LazyMap
getNoteApplicationData(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
Get the value of a single entry in the applicationData map for the note identified by GUID.string
getNoteApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@throws EDAMNotFoundException
Update, or create, an entry in the applicationData map for the note identified by guid.i32
setNoteApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key,string
value) throwsErrors.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.i32
unsetNoteApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key) throwsErrors.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).string
getNoteContent(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the note to be retrieved.
@throws EDAMUserException
@throws 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.string
getNoteSearchText(string
authenticationToken,Types.Guid
guid,bool
noteOnly,bool
tokenizeForIndexing) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws 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.string
getResourceSearchText(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.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 to be retrieved.
@throws EDAMUserException
@throws 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.list<
getNoteTagNames(string
>string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@throws EDAMUserException
@throws EDAMNotFoundException
Asks the service to make a note with the provided set of information.Types.Note
createNote(string
authenticationToken,Types.Note
note) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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.Types.Note
updateNote(string
authenticationToken,Types.Note
note) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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 = falsei32
deleteNote(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the note to delete.
@return The Update Sequence Number for this change within the account.
@throws EDAMUserException
@throws EDAMUserException
Permanently removes a Note, and all of its Resources, from the service.i32
expungeNote(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws 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.Types.Note
copyNote(string
authenticationToken,Types.Guid
noteGuid,Types.Guid
toNotebookGuid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
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
@throws 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.)list<
listNoteVersions(NoteVersionId
>string
authenticationToken,Types.Guid
noteGuid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@throws EDAMUserException
@throws 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.)Types.Note
getNoteVersion(string
authenticationToken,Types.Guid
noteGuid,i32
updateSequenceNum,bool
withResourcesData,bool
withResourcesRecognition,bool
withResourcesAlternateData) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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.Types.Resource
getResource(string
authenticationToken,Types.Guid
guid,bool
withData,bool
withRecognition,bool
withAttributes,bool
withAlternateData) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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.Types.LazyMap
getResourceApplicationData(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
Get the value of a single entry in the applicationData map for the Resource identified by GUID.string
getResourceApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@throws EDAMNotFoundException
Update, or create, an entry in the applicationData map for the Resource identified by guid.i32
setResourceApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key,string
value) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
Remove an entry identified by 'key' from the applicationData map for the Resource identified by 'guid'.i32
unsetResourceApplicationDataEntry(string
authenticationToken,Types.Guid
guid,string
key) throwsErrors.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.i32
updateResource(string
authenticationToken,Types.Resource
resource) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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:
@return The Update Sequence Number of the resource after the changes have been applied.
@throws EDAMUserException
@throws 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).string
getResourceData(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the resource to be retrieved.
@throws EDAMUserException
@throws EDAMNotFoundException
Returns the current state of a resource, referenced by containing note GUID and resource content hash.Types.Resource
getResourceByHash(string
authenticationToken,Types.Guid
noteGuid,string
contentHash,bool
withData,bool
withRecognition,bool
withAlternateData) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws 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).string
getResourceRecognition(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the resource whose recognition data should be retrieved.
@throws EDAMUserException
@throws 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.string
getResourceAlternateData(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the resource whose recognition data should be retrieved.
@throws EDAMUserException
@throws 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).Types.ResourceAttributes
getResourceAttributes(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@param guid The GUID of the resource whose attributes should be retrieved.
@throws EDAMUserException
@throws EDAMNotFoundException
Types.Notebook
getPublicNotebook(Types.UserID
userId,string
publicUri) throwsErrors.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
@throws EDAMSystemException
@Deprecated for first-party clients. See createOrUpdateNotebookShares.Types.SharedNotebook
shareNotebook(string
authenticationToken,Types.SharedNotebook
sharedNotebook,string
message) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
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.CreateOrUpdateNotebookSharesResult
createOrUpdateNotebookShares(string
authenticationToken,NotebookShareTemplate
shareTemplate) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
,Errors.EDAMInvalidContactsException
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
@throws EDAMInvalidContactsException
@throws EDAMNotFoundException
@Deprecated See createOrUpdateNotebookShares and manageNotebookShares.i32
updateSharedNotebook(string
authenticationToken,Types.SharedNotebook
sharedNotebook) throwsErrors.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.Types.Notebook
setNotebookRecipientSettings(string
authenticationToken,string
notebookGuid,Types.NotebookRecipientSettings
recipientSettings) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
@throws EDAMUserException
Lists the collection of shared notebooks for all notebooks in the users account.list<
listSharedNotebooks(Types.SharedNotebook
>string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@return
The list of all SharedNotebooks for the user
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.Types.LinkedNotebook
createLinkedNotebook(string
authenticationToken,Types.LinkedNotebook
linkedNotebook) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@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
@throws EDAMSystemException
@param linkedNotebook Updates the name of a linked notebook.i32
updateLinkedNotebook(string
authenticationToken,Types.LinkedNotebook
linkedNotebook) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@return The Update Sequence Number for this change within the account.
@throws EDAMUserException
Returns a list of linked notebookslist<
listLinkedNotebooks(Types.LinkedNotebook
>string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
Permanently expunges the linked notebook from the account.i32
expungeLinkedNotebook(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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.
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.UserStore.AuthenticationResult
authenticateToSharedNotebook(string
shareKeyOrGlobalId,string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@param shareKeyOrGlobalId May be one of the following:
@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
@throws EDAMNotFoundException
@throws EDAMUserException
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.Types.SharedNotebook
getSharedNotebookByAuth(string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@param authenticationToken Should be the authentication token retrieved from the reply of authenticateToSharedNotebook(), proving access to a particular shared notebook.
@throws EDAMUserException
@throws EDAMNotFoundException
Attempts to send a single note to one or more email recipients.void
emailNote(string
authenticationToken,NoteEmailParameters
parameters) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
@throws EDAMNotFoundException
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.string
shareNote(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@param guid The GUID of the note to be shared.
@throws EDAMUserException
@throws EDAMNotFoundException
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.void
stopSharingNote(string
authenticationToken,Types.Guid
guid) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
@throws EDAMNotFoundException
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.UserStore.AuthenticationResult
authenticateToSharedNote(string
guid,string
noteKey,string
authenticationToken) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
@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
@throws EDAMNotFoundException
@throws EDAMSystemException
Identify related entities on the service, such as notes, notebooks, tags and users in a business related to notes or content.RelatedResult
findRelated(string
authenticationToken,RelatedQuery
query,RelatedResultSpec
resultSpec) throwsErrors.EDAMUserException
,Errors.EDAMSystemException
,Errors.EDAMNotFoundException
@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
@throws EDAMNotFoundException
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.UpdateNoteIfUsnMatchesResult
updateNoteIfUsnMatches(string
authenticationToken,Types.Note
note) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
Manage invitations and memberships associated with a given notebook.ManageNotebookSharesResult
manageNotebookShares(string
authenticationToken,ManageNotebookSharesParameters
parameters) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
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
Return the share relationships for the given notebook, including both the invitations and the memberships.ShareRelationships
getNotebookShares(string
authenticationToken,string
notebookGuid) throwsErrors.EDAMUserException
,Errors.EDAMNotFoundException
,Errors.EDAMSystemException
Note: Beta method! This method is currently intended for
limited use by Evernote clients that have discussed using this
routine with the platform team.