/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Thrift;
using Thrift.Collections;
using Thrift.Protocol;
using Thrift.Transport;
namespace Evernote.EDAM.NoteStore
{
  public class NoteStore {
    public interface Iface {
      SyncState getSyncState(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getSyncState(AsyncCallback callback, object state, string authenticationToken);
      SyncState End_getSyncState(IAsyncResult asyncResult);
      #endif
      SyncState getSyncStateWithMetrics(string authenticationToken, ClientUsageMetrics clientMetrics);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getSyncStateWithMetrics(AsyncCallback callback, object state, string authenticationToken, ClientUsageMetrics clientMetrics);
      SyncState End_getSyncStateWithMetrics(IAsyncResult asyncResult);
      #endif
      SyncChunk getSyncChunk(string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly);
      SyncChunk End_getSyncChunk(IAsyncResult asyncResult);
      #endif
      SyncChunk getFilteredSyncChunk(string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getFilteredSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter);
      SyncChunk End_getFilteredSyncChunk(IAsyncResult asyncResult);
      #endif
      SyncState getLinkedNotebookSyncState(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getLinkedNotebookSyncState(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      SyncState End_getLinkedNotebookSyncState(IAsyncResult asyncResult);
      #endif
      SyncChunk getLinkedNotebookSyncChunk(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getLinkedNotebookSyncChunk(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly);
      SyncChunk End_getLinkedNotebookSyncChunk(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.Notebook> listNotebooks(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listNotebooks(AsyncCallback callback, object state, string authenticationToken);
      List<Evernote.EDAM.Type.Notebook> End_listNotebooks(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Notebook getNotebook(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNotebook(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.Notebook End_getNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Notebook getDefaultNotebook(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getDefaultNotebook(AsyncCallback callback, object state, string authenticationToken);
      Evernote.EDAM.Type.Notebook End_getDefaultNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Notebook createNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook);
      Evernote.EDAM.Type.Notebook End_createNotebook(IAsyncResult asyncResult);
      #endif
      int updateNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook);
      int End_updateNotebook(IAsyncResult asyncResult);
      #endif
      int expungeNotebook(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeNotebook(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_expungeNotebook(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.Tag> listTags(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listTags(AsyncCallback callback, object state, string authenticationToken);
      List<Evernote.EDAM.Type.Tag> End_listTags(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.Tag> listTagsByNotebook(string authenticationToken, string notebookGuid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listTagsByNotebook(AsyncCallback callback, object state, string authenticationToken, string notebookGuid);
      List<Evernote.EDAM.Type.Tag> End_listTagsByNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Tag getTag(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getTag(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.Tag End_getTag(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Tag createTag(string authenticationToken, Evernote.EDAM.Type.Tag tag);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag);
      Evernote.EDAM.Type.Tag End_createTag(IAsyncResult asyncResult);
      #endif
      int updateTag(string authenticationToken, Evernote.EDAM.Type.Tag tag);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag);
      int End_updateTag(IAsyncResult asyncResult);
      #endif
      void untagAll(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_untagAll(AsyncCallback callback, object state, string authenticationToken, string guid);
      void End_untagAll(IAsyncResult asyncResult);
      #endif
      int expungeTag(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeTag(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_expungeTag(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.SavedSearch> listSearches(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listSearches(AsyncCallback callback, object state, string authenticationToken);
      List<Evernote.EDAM.Type.SavedSearch> End_listSearches(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.SavedSearch getSearch(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getSearch(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.SavedSearch End_getSearch(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.SavedSearch createSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search);
      Evernote.EDAM.Type.SavedSearch End_createSearch(IAsyncResult asyncResult);
      #endif
      int updateSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search);
      int End_updateSearch(IAsyncResult asyncResult);
      #endif
      int expungeSearch(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeSearch(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_expungeSearch(IAsyncResult asyncResult);
      #endif
      NoteList findNotes(string authenticationToken, NoteFilter filter, int offset, int maxNotes);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_findNotes(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes);
      NoteList End_findNotes(IAsyncResult asyncResult);
      #endif
      int findNoteOffset(string authenticationToken, NoteFilter filter, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_findNoteOffset(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, string guid);
      int End_findNoteOffset(IAsyncResult asyncResult);
      #endif
      NotesMetadataList findNotesMetadata(string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_findNotesMetadata(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec);
      NotesMetadataList End_findNotesMetadata(IAsyncResult asyncResult);
      #endif
      NoteCollectionCounts findNoteCounts(string authenticationToken, NoteFilter filter, bool withTrash);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_findNoteCounts(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, bool withTrash);
      NoteCollectionCounts End_findNoteCounts(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Note getNote(string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNote(AsyncCallback callback, object state, string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData);
      Evernote.EDAM.Type.Note End_getNote(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.LazyMap getNoteApplicationData(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.LazyMap End_getNoteApplicationData(IAsyncResult asyncResult);
      #endif
      string getNoteApplicationDataEntry(string authenticationToken, string guid, string key);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key);
      string End_getNoteApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      int setNoteApplicationDataEntry(string authenticationToken, string guid, string key, string value);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_setNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value);
      int End_setNoteApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      int unsetNoteApplicationDataEntry(string authenticationToken, string guid, string key);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_unsetNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key);
      int End_unsetNoteApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      string getNoteContent(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteContent(AsyncCallback callback, object state, string authenticationToken, string guid);
      string End_getNoteContent(IAsyncResult asyncResult);
      #endif
      string getNoteSearchText(string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteSearchText(AsyncCallback callback, object state, string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing);
      string End_getNoteSearchText(IAsyncResult asyncResult);
      #endif
      string getResourceSearchText(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceSearchText(AsyncCallback callback, object state, string authenticationToken, string guid);
      string End_getResourceSearchText(IAsyncResult asyncResult);
      #endif
      List<string> getNoteTagNames(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteTagNames(AsyncCallback callback, object state, string authenticationToken, string guid);
      List<string> End_getNoteTagNames(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Note createNote(string authenticationToken, Evernote.EDAM.Type.Note note);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note);
      Evernote.EDAM.Type.Note End_createNote(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Note updateNote(string authenticationToken, Evernote.EDAM.Type.Note note);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note);
      Evernote.EDAM.Type.Note End_updateNote(IAsyncResult asyncResult);
      #endif
      int deleteNote(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_deleteNote(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_deleteNote(IAsyncResult asyncResult);
      #endif
      int expungeNote(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeNote(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_expungeNote(IAsyncResult asyncResult);
      #endif
      int expungeNotes(string authenticationToken, List<string> noteGuids);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeNotes(AsyncCallback callback, object state, string authenticationToken, List<string> noteGuids);
      int End_expungeNotes(IAsyncResult asyncResult);
      #endif
      int expungeInactiveNotes(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeInactiveNotes(AsyncCallback callback, object state, string authenticationToken);
      int End_expungeInactiveNotes(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Note copyNote(string authenticationToken, string noteGuid, string toNotebookGuid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_copyNote(AsyncCallback callback, object state, string authenticationToken, string noteGuid, string toNotebookGuid);
      Evernote.EDAM.Type.Note End_copyNote(IAsyncResult asyncResult);
      #endif
      List<NoteVersionId> listNoteVersions(string authenticationToken, string noteGuid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listNoteVersions(AsyncCallback callback, object state, string authenticationToken, string noteGuid);
      List<NoteVersionId> End_listNoteVersions(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Note getNoteVersion(string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getNoteVersion(AsyncCallback callback, object state, string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData);
      Evernote.EDAM.Type.Note End_getNoteVersion(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Resource getResource(string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResource(AsyncCallback callback, object state, string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData);
      Evernote.EDAM.Type.Resource End_getResource(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.LazyMap getResourceApplicationData(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.LazyMap End_getResourceApplicationData(IAsyncResult asyncResult);
      #endif
      string getResourceApplicationDataEntry(string authenticationToken, string guid, string key);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key);
      string End_getResourceApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      int setResourceApplicationDataEntry(string authenticationToken, string guid, string key, string value);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_setResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value);
      int End_setResourceApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      int unsetResourceApplicationDataEntry(string authenticationToken, string guid, string key);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_unsetResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key);
      int End_unsetResourceApplicationDataEntry(IAsyncResult asyncResult);
      #endif
      int updateResource(string authenticationToken, Evernote.EDAM.Type.Resource resource);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateResource(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Resource resource);
      int End_updateResource(IAsyncResult asyncResult);
      #endif
      byte[] getResourceData(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceData(AsyncCallback callback, object state, string authenticationToken, string guid);
      byte[] End_getResourceData(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Resource getResourceByHash(string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceByHash(AsyncCallback callback, object state, string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData);
      Evernote.EDAM.Type.Resource End_getResourceByHash(IAsyncResult asyncResult);
      #endif
      byte[] getResourceRecognition(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceRecognition(AsyncCallback callback, object state, string authenticationToken, string guid);
      byte[] End_getResourceRecognition(IAsyncResult asyncResult);
      #endif
      byte[] getResourceAlternateData(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceAlternateData(AsyncCallback callback, object state, string authenticationToken, string guid);
      byte[] End_getResourceAlternateData(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.ResourceAttributes getResourceAttributes(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getResourceAttributes(AsyncCallback callback, object state, string authenticationToken, string guid);
      Evernote.EDAM.Type.ResourceAttributes End_getResourceAttributes(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.Notebook getPublicNotebook(int userId, string publicUri);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getPublicNotebook(AsyncCallback callback, object state, int userId, string publicUri);
      Evernote.EDAM.Type.Notebook End_getPublicNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.SharedNotebook createSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook);
      Evernote.EDAM.Type.SharedNotebook End_createSharedNotebook(IAsyncResult asyncResult);
      #endif
      int updateSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook);
      int End_updateSharedNotebook(IAsyncResult asyncResult);
      #endif
      int setSharedNotebookRecipientSettings(string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_setSharedNotebookRecipientSettings(AsyncCallback callback, object state, string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings);
      int End_setSharedNotebookRecipientSettings(IAsyncResult asyncResult);
      #endif
      int sendMessageToSharedNotebookMembers(string authenticationToken, string notebookGuid, string messageText, List<string> recipients);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_sendMessageToSharedNotebookMembers(AsyncCallback callback, object state, string authenticationToken, string notebookGuid, string messageText, List<string> recipients);
      int End_sendMessageToSharedNotebookMembers(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.SharedNotebook> listSharedNotebooks(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listSharedNotebooks(AsyncCallback callback, object state, string authenticationToken);
      List<Evernote.EDAM.Type.SharedNotebook> End_listSharedNotebooks(IAsyncResult asyncResult);
      #endif
      int expungeSharedNotebooks(string authenticationToken, List<long> sharedNotebookIds);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeSharedNotebooks(AsyncCallback callback, object state, string authenticationToken, List<long> sharedNotebookIds);
      int End_expungeSharedNotebooks(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.LinkedNotebook createLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_createLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      Evernote.EDAM.Type.LinkedNotebook End_createLinkedNotebook(IAsyncResult asyncResult);
      #endif
      int updateLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_updateLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook);
      int End_updateLinkedNotebook(IAsyncResult asyncResult);
      #endif
      List<Evernote.EDAM.Type.LinkedNotebook> listLinkedNotebooks(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_listLinkedNotebooks(AsyncCallback callback, object state, string authenticationToken);
      List<Evernote.EDAM.Type.LinkedNotebook> End_listLinkedNotebooks(IAsyncResult asyncResult);
      #endif
      int expungeLinkedNotebook(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_expungeLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, string guid);
      int End_expungeLinkedNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.UserStore.AuthenticationResult authenticateToSharedNotebook(string shareKey, string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_authenticateToSharedNotebook(AsyncCallback callback, object state, string shareKey, string authenticationToken);
      Evernote.EDAM.UserStore.AuthenticationResult End_authenticateToSharedNotebook(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.Type.SharedNotebook getSharedNotebookByAuth(string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_getSharedNotebookByAuth(AsyncCallback callback, object state, string authenticationToken);
      Evernote.EDAM.Type.SharedNotebook End_getSharedNotebookByAuth(IAsyncResult asyncResult);
      #endif
      void emailNote(string authenticationToken, NoteEmailParameters parameters);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_emailNote(AsyncCallback callback, object state, string authenticationToken, NoteEmailParameters parameters);
      void End_emailNote(IAsyncResult asyncResult);
      #endif
      string shareNote(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_shareNote(AsyncCallback callback, object state, string authenticationToken, string guid);
      string End_shareNote(IAsyncResult asyncResult);
      #endif
      void stopSharingNote(string authenticationToken, string guid);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_stopSharingNote(AsyncCallback callback, object state, string authenticationToken, string guid);
      void End_stopSharingNote(IAsyncResult asyncResult);
      #endif
      Evernote.EDAM.UserStore.AuthenticationResult authenticateToSharedNote(string guid, string noteKey, string authenticationToken);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_authenticateToSharedNote(AsyncCallback callback, object state, string guid, string noteKey, string authenticationToken);
      Evernote.EDAM.UserStore.AuthenticationResult End_authenticateToSharedNote(IAsyncResult asyncResult);
      #endif
      RelatedResult findRelated(string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec);
      #if SILVERLIGHT || NETFX_CORE
      IAsyncResult Begin_findRelated(AsyncCallback callback, object state, string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec);
      RelatedResult End_findRelated(IAsyncResult asyncResult);
      #endif
    }

    public class Client : Iface {
      public Client(TProtocol prot) : this(prot, prot)
      {
      }

      public Client(TProtocol iprot, TProtocol oprot)
      {
        iprot_ = iprot;
        oprot_ = oprot;
      }

      protected TProtocol iprot_;
      protected TProtocol oprot_;
      protected int seqid_;

      public TProtocol InputProtocol
      {
        get { return iprot_; }
      }
      public TProtocol OutputProtocol
      {
        get { return oprot_; }
      }


      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getSyncState(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_getSyncState(callback, state, authenticationToken);
      }

      public SyncState End_getSyncState(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getSyncState();
      }

      #endif
      public SyncState getSyncState(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getSyncState(authenticationToken);
        return recv_getSyncState();

        #else
        var asyncResult = Begin_getSyncState(null, null, authenticationToken);
        return End_getSyncState(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getSyncState(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_getSyncState(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getSyncState", TMessageType.Call, seqid_));
        getSyncState_args args = new getSyncState_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncState recv_getSyncState()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getSyncState_result result = new getSyncState_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getSyncState failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getSyncStateWithMetrics(AsyncCallback callback, object state, string authenticationToken, ClientUsageMetrics clientMetrics)
      {
        return send_getSyncStateWithMetrics(callback, state, authenticationToken, clientMetrics);
      }

      public SyncState End_getSyncStateWithMetrics(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getSyncStateWithMetrics();
      }

      #endif
      public SyncState getSyncStateWithMetrics(string authenticationToken, ClientUsageMetrics clientMetrics)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getSyncStateWithMetrics(authenticationToken, clientMetrics);
        return recv_getSyncStateWithMetrics();

        #else
        var asyncResult = Begin_getSyncStateWithMetrics(null, null, authenticationToken, clientMetrics);
        return End_getSyncStateWithMetrics(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getSyncStateWithMetrics(AsyncCallback callback, object state, string authenticationToken, ClientUsageMetrics clientMetrics)
      #else
      public void send_getSyncStateWithMetrics(string authenticationToken, ClientUsageMetrics clientMetrics)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getSyncStateWithMetrics", TMessageType.Call, seqid_));
        getSyncStateWithMetrics_args args = new getSyncStateWithMetrics_args();
        args.AuthenticationToken = authenticationToken;
        args.ClientMetrics = clientMetrics;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncState recv_getSyncStateWithMetrics()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getSyncStateWithMetrics_result result = new getSyncStateWithMetrics_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getSyncStateWithMetrics failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly)
      {
        return send_getSyncChunk(callback, state, authenticationToken, afterUSN, maxEntries, fullSyncOnly);
      }

      public SyncChunk End_getSyncChunk(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getSyncChunk();
      }

      #endif
      public SyncChunk getSyncChunk(string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getSyncChunk(authenticationToken, afterUSN, maxEntries, fullSyncOnly);
        return recv_getSyncChunk();

        #else
        var asyncResult = Begin_getSyncChunk(null, null, authenticationToken, afterUSN, maxEntries, fullSyncOnly);
        return End_getSyncChunk(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly)
      #else
      public void send_getSyncChunk(string authenticationToken, int afterUSN, int maxEntries, bool fullSyncOnly)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getSyncChunk", TMessageType.Call, seqid_));
        getSyncChunk_args args = new getSyncChunk_args();
        args.AuthenticationToken = authenticationToken;
        args.AfterUSN = afterUSN;
        args.MaxEntries = maxEntries;
        args.FullSyncOnly = fullSyncOnly;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncChunk recv_getSyncChunk()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getSyncChunk_result result = new getSyncChunk_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getSyncChunk failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getFilteredSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter)
      {
        return send_getFilteredSyncChunk(callback, state, authenticationToken, afterUSN, maxEntries, filter);
      }

      public SyncChunk End_getFilteredSyncChunk(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getFilteredSyncChunk();
      }

      #endif
      public SyncChunk getFilteredSyncChunk(string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getFilteredSyncChunk(authenticationToken, afterUSN, maxEntries, filter);
        return recv_getFilteredSyncChunk();

        #else
        var asyncResult = Begin_getFilteredSyncChunk(null, null, authenticationToken, afterUSN, maxEntries, filter);
        return End_getFilteredSyncChunk(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getFilteredSyncChunk(AsyncCallback callback, object state, string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter)
      #else
      public void send_getFilteredSyncChunk(string authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getFilteredSyncChunk", TMessageType.Call, seqid_));
        getFilteredSyncChunk_args args = new getFilteredSyncChunk_args();
        args.AuthenticationToken = authenticationToken;
        args.AfterUSN = afterUSN;
        args.MaxEntries = maxEntries;
        args.Filter = filter;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncChunk recv_getFilteredSyncChunk()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getFilteredSyncChunk_result result = new getFilteredSyncChunk_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getFilteredSyncChunk failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getLinkedNotebookSyncState(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        return send_getLinkedNotebookSyncState(callback, state, authenticationToken, linkedNotebook);
      }

      public SyncState End_getLinkedNotebookSyncState(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getLinkedNotebookSyncState();
      }

      #endif
      public SyncState getLinkedNotebookSyncState(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getLinkedNotebookSyncState(authenticationToken, linkedNotebook);
        return recv_getLinkedNotebookSyncState();

        #else
        var asyncResult = Begin_getLinkedNotebookSyncState(null, null, authenticationToken, linkedNotebook);
        return End_getLinkedNotebookSyncState(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getLinkedNotebookSyncState(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #else
      public void send_getLinkedNotebookSyncState(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getLinkedNotebookSyncState", TMessageType.Call, seqid_));
        getLinkedNotebookSyncState_args args = new getLinkedNotebookSyncState_args();
        args.AuthenticationToken = authenticationToken;
        args.LinkedNotebook = linkedNotebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncState recv_getLinkedNotebookSyncState()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getLinkedNotebookSyncState_result result = new getLinkedNotebookSyncState_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getLinkedNotebookSyncState failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getLinkedNotebookSyncChunk(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly)
      {
        return send_getLinkedNotebookSyncChunk(callback, state, authenticationToken, linkedNotebook, afterUSN, maxEntries, fullSyncOnly);
      }

      public SyncChunk End_getLinkedNotebookSyncChunk(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getLinkedNotebookSyncChunk();
      }

      #endif
      public SyncChunk getLinkedNotebookSyncChunk(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getLinkedNotebookSyncChunk(authenticationToken, linkedNotebook, afterUSN, maxEntries, fullSyncOnly);
        return recv_getLinkedNotebookSyncChunk();

        #else
        var asyncResult = Begin_getLinkedNotebookSyncChunk(null, null, authenticationToken, linkedNotebook, afterUSN, maxEntries, fullSyncOnly);
        return End_getLinkedNotebookSyncChunk(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getLinkedNotebookSyncChunk(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly)
      #else
      public void send_getLinkedNotebookSyncChunk(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, bool fullSyncOnly)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getLinkedNotebookSyncChunk", TMessageType.Call, seqid_));
        getLinkedNotebookSyncChunk_args args = new getLinkedNotebookSyncChunk_args();
        args.AuthenticationToken = authenticationToken;
        args.LinkedNotebook = linkedNotebook;
        args.AfterUSN = afterUSN;
        args.MaxEntries = maxEntries;
        args.FullSyncOnly = fullSyncOnly;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public SyncChunk recv_getLinkedNotebookSyncChunk()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getLinkedNotebookSyncChunk_result result = new getLinkedNotebookSyncChunk_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getLinkedNotebookSyncChunk failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listNotebooks(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_listNotebooks(callback, state, authenticationToken);
      }

      public List<Evernote.EDAM.Type.Notebook> End_listNotebooks(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listNotebooks();
      }

      #endif
      public List<Evernote.EDAM.Type.Notebook> listNotebooks(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listNotebooks(authenticationToken);
        return recv_listNotebooks();

        #else
        var asyncResult = Begin_listNotebooks(null, null, authenticationToken);
        return End_listNotebooks(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listNotebooks(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_listNotebooks(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listNotebooks", TMessageType.Call, seqid_));
        listNotebooks_args args = new listNotebooks_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.Notebook> recv_listNotebooks()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listNotebooks_result result = new listNotebooks_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listNotebooks failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getNotebook(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.Notebook End_getNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNotebook();
      }

      #endif
      public Evernote.EDAM.Type.Notebook getNotebook(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNotebook(authenticationToken, guid);
        return recv_getNotebook();

        #else
        var asyncResult = Begin_getNotebook(null, null, authenticationToken, guid);
        return End_getNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getNotebook(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNotebook", TMessageType.Call, seqid_));
        getNotebook_args args = new getNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Notebook recv_getNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNotebook_result result = new getNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getDefaultNotebook(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_getDefaultNotebook(callback, state, authenticationToken);
      }

      public Evernote.EDAM.Type.Notebook End_getDefaultNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getDefaultNotebook();
      }

      #endif
      public Evernote.EDAM.Type.Notebook getDefaultNotebook(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getDefaultNotebook(authenticationToken);
        return recv_getDefaultNotebook();

        #else
        var asyncResult = Begin_getDefaultNotebook(null, null, authenticationToken);
        return End_getDefaultNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getDefaultNotebook(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_getDefaultNotebook(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getDefaultNotebook", TMessageType.Call, seqid_));
        getDefaultNotebook_args args = new getDefaultNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Notebook recv_getDefaultNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getDefaultNotebook_result result = new getDefaultNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getDefaultNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      {
        return send_createNotebook(callback, state, authenticationToken, notebook);
      }

      public Evernote.EDAM.Type.Notebook End_createNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createNotebook();
      }

      #endif
      public Evernote.EDAM.Type.Notebook createNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createNotebook(authenticationToken, notebook);
        return recv_createNotebook();

        #else
        var asyncResult = Begin_createNotebook(null, null, authenticationToken, notebook);
        return End_createNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      #else
      public void send_createNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createNotebook", TMessageType.Call, seqid_));
        createNotebook_args args = new createNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Notebook = notebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Notebook recv_createNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createNotebook_result result = new createNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      {
        return send_updateNotebook(callback, state, authenticationToken, notebook);
      }

      public int End_updateNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateNotebook();
      }

      #endif
      public int updateNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateNotebook(authenticationToken, notebook);
        return recv_updateNotebook();

        #else
        var asyncResult = Begin_updateNotebook(null, null, authenticationToken, notebook);
        return End_updateNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      #else
      public void send_updateNotebook(string authenticationToken, Evernote.EDAM.Type.Notebook notebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateNotebook", TMessageType.Call, seqid_));
        updateNotebook_args args = new updateNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Notebook = notebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateNotebook_result result = new updateNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_expungeNotebook(callback, state, authenticationToken, guid);
      }

      public int End_expungeNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeNotebook();
      }

      #endif
      public int expungeNotebook(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeNotebook(authenticationToken, guid);
        return recv_expungeNotebook();

        #else
        var asyncResult = Begin_expungeNotebook(null, null, authenticationToken, guid);
        return End_expungeNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_expungeNotebook(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeNotebook", TMessageType.Call, seqid_));
        expungeNotebook_args args = new expungeNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeNotebook_result result = new expungeNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listTags(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_listTags(callback, state, authenticationToken);
      }

      public List<Evernote.EDAM.Type.Tag> End_listTags(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listTags();
      }

      #endif
      public List<Evernote.EDAM.Type.Tag> listTags(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listTags(authenticationToken);
        return recv_listTags();

        #else
        var asyncResult = Begin_listTags(null, null, authenticationToken);
        return End_listTags(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listTags(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_listTags(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listTags", TMessageType.Call, seqid_));
        listTags_args args = new listTags_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.Tag> recv_listTags()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listTags_result result = new listTags_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listTags failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listTagsByNotebook(AsyncCallback callback, object state, string authenticationToken, string notebookGuid)
      {
        return send_listTagsByNotebook(callback, state, authenticationToken, notebookGuid);
      }

      public List<Evernote.EDAM.Type.Tag> End_listTagsByNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listTagsByNotebook();
      }

      #endif
      public List<Evernote.EDAM.Type.Tag> listTagsByNotebook(string authenticationToken, string notebookGuid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listTagsByNotebook(authenticationToken, notebookGuid);
        return recv_listTagsByNotebook();

        #else
        var asyncResult = Begin_listTagsByNotebook(null, null, authenticationToken, notebookGuid);
        return End_listTagsByNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listTagsByNotebook(AsyncCallback callback, object state, string authenticationToken, string notebookGuid)
      #else
      public void send_listTagsByNotebook(string authenticationToken, string notebookGuid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listTagsByNotebook", TMessageType.Call, seqid_));
        listTagsByNotebook_args args = new listTagsByNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.NotebookGuid = notebookGuid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.Tag> recv_listTagsByNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listTagsByNotebook_result result = new listTagsByNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listTagsByNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getTag(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getTag(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.Tag End_getTag(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getTag();
      }

      #endif
      public Evernote.EDAM.Type.Tag getTag(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getTag(authenticationToken, guid);
        return recv_getTag();

        #else
        var asyncResult = Begin_getTag(null, null, authenticationToken, guid);
        return End_getTag(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getTag(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getTag(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getTag", TMessageType.Call, seqid_));
        getTag_args args = new getTag_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Tag recv_getTag()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getTag_result result = new getTag_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getTag failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag)
      {
        return send_createTag(callback, state, authenticationToken, tag);
      }

      public Evernote.EDAM.Type.Tag End_createTag(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createTag();
      }

      #endif
      public Evernote.EDAM.Type.Tag createTag(string authenticationToken, Evernote.EDAM.Type.Tag tag)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createTag(authenticationToken, tag);
        return recv_createTag();

        #else
        var asyncResult = Begin_createTag(null, null, authenticationToken, tag);
        return End_createTag(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag)
      #else
      public void send_createTag(string authenticationToken, Evernote.EDAM.Type.Tag tag)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createTag", TMessageType.Call, seqid_));
        createTag_args args = new createTag_args();
        args.AuthenticationToken = authenticationToken;
        args.Tag = tag;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Tag recv_createTag()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createTag_result result = new createTag_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createTag failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag)
      {
        return send_updateTag(callback, state, authenticationToken, tag);
      }

      public int End_updateTag(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateTag();
      }

      #endif
      public int updateTag(string authenticationToken, Evernote.EDAM.Type.Tag tag)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateTag(authenticationToken, tag);
        return recv_updateTag();

        #else
        var asyncResult = Begin_updateTag(null, null, authenticationToken, tag);
        return End_updateTag(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateTag(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Tag tag)
      #else
      public void send_updateTag(string authenticationToken, Evernote.EDAM.Type.Tag tag)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateTag", TMessageType.Call, seqid_));
        updateTag_args args = new updateTag_args();
        args.AuthenticationToken = authenticationToken;
        args.Tag = tag;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateTag()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateTag_result result = new updateTag_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateTag failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_untagAll(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_untagAll(callback, state, authenticationToken, guid);
      }

      public void End_untagAll(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        recv_untagAll();
      }

      #endif
      public void untagAll(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_untagAll(authenticationToken, guid);
        recv_untagAll();

        #else
        var asyncResult = Begin_untagAll(null, null, authenticationToken, guid);
        End_untagAll(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_untagAll(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_untagAll(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("untagAll", TMessageType.Call, seqid_));
        untagAll_args args = new untagAll_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public void recv_untagAll()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        untagAll_result result = new untagAll_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        return;
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeTag(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_expungeTag(callback, state, authenticationToken, guid);
      }

      public int End_expungeTag(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeTag();
      }

      #endif
      public int expungeTag(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeTag(authenticationToken, guid);
        return recv_expungeTag();

        #else
        var asyncResult = Begin_expungeTag(null, null, authenticationToken, guid);
        return End_expungeTag(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeTag(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_expungeTag(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeTag", TMessageType.Call, seqid_));
        expungeTag_args args = new expungeTag_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeTag()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeTag_result result = new expungeTag_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeTag failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listSearches(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_listSearches(callback, state, authenticationToken);
      }

      public List<Evernote.EDAM.Type.SavedSearch> End_listSearches(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listSearches();
      }

      #endif
      public List<Evernote.EDAM.Type.SavedSearch> listSearches(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listSearches(authenticationToken);
        return recv_listSearches();

        #else
        var asyncResult = Begin_listSearches(null, null, authenticationToken);
        return End_listSearches(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listSearches(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_listSearches(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listSearches", TMessageType.Call, seqid_));
        listSearches_args args = new listSearches_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.SavedSearch> recv_listSearches()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listSearches_result result = new listSearches_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listSearches failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getSearch(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getSearch(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.SavedSearch End_getSearch(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getSearch();
      }

      #endif
      public Evernote.EDAM.Type.SavedSearch getSearch(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getSearch(authenticationToken, guid);
        return recv_getSearch();

        #else
        var asyncResult = Begin_getSearch(null, null, authenticationToken, guid);
        return End_getSearch(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getSearch(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getSearch(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getSearch", TMessageType.Call, seqid_));
        getSearch_args args = new getSearch_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.SavedSearch recv_getSearch()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getSearch_result result = new getSearch_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getSearch failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      {
        return send_createSearch(callback, state, authenticationToken, search);
      }

      public Evernote.EDAM.Type.SavedSearch End_createSearch(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createSearch();
      }

      #endif
      public Evernote.EDAM.Type.SavedSearch createSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createSearch(authenticationToken, search);
        return recv_createSearch();

        #else
        var asyncResult = Begin_createSearch(null, null, authenticationToken, search);
        return End_createSearch(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      #else
      public void send_createSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createSearch", TMessageType.Call, seqid_));
        createSearch_args args = new createSearch_args();
        args.AuthenticationToken = authenticationToken;
        args.Search = search;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.SavedSearch recv_createSearch()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createSearch_result result = new createSearch_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createSearch failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      {
        return send_updateSearch(callback, state, authenticationToken, search);
      }

      public int End_updateSearch(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateSearch();
      }

      #endif
      public int updateSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateSearch(authenticationToken, search);
        return recv_updateSearch();

        #else
        var asyncResult = Begin_updateSearch(null, null, authenticationToken, search);
        return End_updateSearch(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateSearch(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      #else
      public void send_updateSearch(string authenticationToken, Evernote.EDAM.Type.SavedSearch search)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateSearch", TMessageType.Call, seqid_));
        updateSearch_args args = new updateSearch_args();
        args.AuthenticationToken = authenticationToken;
        args.Search = search;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateSearch()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateSearch_result result = new updateSearch_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateSearch failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeSearch(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_expungeSearch(callback, state, authenticationToken, guid);
      }

      public int End_expungeSearch(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeSearch();
      }

      #endif
      public int expungeSearch(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeSearch(authenticationToken, guid);
        return recv_expungeSearch();

        #else
        var asyncResult = Begin_expungeSearch(null, null, authenticationToken, guid);
        return End_expungeSearch(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeSearch(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_expungeSearch(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeSearch", TMessageType.Call, seqid_));
        expungeSearch_args args = new expungeSearch_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeSearch()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeSearch_result result = new expungeSearch_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeSearch failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_findNotes(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes)
      {
        return send_findNotes(callback, state, authenticationToken, filter, offset, maxNotes);
      }

      public NoteList End_findNotes(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_findNotes();
      }

      #endif
      public NoteList findNotes(string authenticationToken, NoteFilter filter, int offset, int maxNotes)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_findNotes(authenticationToken, filter, offset, maxNotes);
        return recv_findNotes();

        #else
        var asyncResult = Begin_findNotes(null, null, authenticationToken, filter, offset, maxNotes);
        return End_findNotes(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_findNotes(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes)
      #else
      public void send_findNotes(string authenticationToken, NoteFilter filter, int offset, int maxNotes)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("findNotes", TMessageType.Call, seqid_));
        findNotes_args args = new findNotes_args();
        args.AuthenticationToken = authenticationToken;
        args.Filter = filter;
        args.Offset = offset;
        args.MaxNotes = maxNotes;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public NoteList recv_findNotes()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        findNotes_result result = new findNotes_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "findNotes failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_findNoteOffset(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, string guid)
      {
        return send_findNoteOffset(callback, state, authenticationToken, filter, guid);
      }

      public int End_findNoteOffset(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_findNoteOffset();
      }

      #endif
      public int findNoteOffset(string authenticationToken, NoteFilter filter, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_findNoteOffset(authenticationToken, filter, guid);
        return recv_findNoteOffset();

        #else
        var asyncResult = Begin_findNoteOffset(null, null, authenticationToken, filter, guid);
        return End_findNoteOffset(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_findNoteOffset(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, string guid)
      #else
      public void send_findNoteOffset(string authenticationToken, NoteFilter filter, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("findNoteOffset", TMessageType.Call, seqid_));
        findNoteOffset_args args = new findNoteOffset_args();
        args.AuthenticationToken = authenticationToken;
        args.Filter = filter;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_findNoteOffset()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        findNoteOffset_result result = new findNoteOffset_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "findNoteOffset failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_findNotesMetadata(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec)
      {
        return send_findNotesMetadata(callback, state, authenticationToken, filter, offset, maxNotes, resultSpec);
      }

      public NotesMetadataList End_findNotesMetadata(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_findNotesMetadata();
      }

      #endif
      public NotesMetadataList findNotesMetadata(string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_findNotesMetadata(authenticationToken, filter, offset, maxNotes, resultSpec);
        return recv_findNotesMetadata();

        #else
        var asyncResult = Begin_findNotesMetadata(null, null, authenticationToken, filter, offset, maxNotes, resultSpec);
        return End_findNotesMetadata(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_findNotesMetadata(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec)
      #else
      public void send_findNotesMetadata(string authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("findNotesMetadata", TMessageType.Call, seqid_));
        findNotesMetadata_args args = new findNotesMetadata_args();
        args.AuthenticationToken = authenticationToken;
        args.Filter = filter;
        args.Offset = offset;
        args.MaxNotes = maxNotes;
        args.ResultSpec = resultSpec;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public NotesMetadataList recv_findNotesMetadata()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        findNotesMetadata_result result = new findNotesMetadata_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "findNotesMetadata failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_findNoteCounts(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, bool withTrash)
      {
        return send_findNoteCounts(callback, state, authenticationToken, filter, withTrash);
      }

      public NoteCollectionCounts End_findNoteCounts(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_findNoteCounts();
      }

      #endif
      public NoteCollectionCounts findNoteCounts(string authenticationToken, NoteFilter filter, bool withTrash)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_findNoteCounts(authenticationToken, filter, withTrash);
        return recv_findNoteCounts();

        #else
        var asyncResult = Begin_findNoteCounts(null, null, authenticationToken, filter, withTrash);
        return End_findNoteCounts(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_findNoteCounts(AsyncCallback callback, object state, string authenticationToken, NoteFilter filter, bool withTrash)
      #else
      public void send_findNoteCounts(string authenticationToken, NoteFilter filter, bool withTrash)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("findNoteCounts", TMessageType.Call, seqid_));
        findNoteCounts_args args = new findNoteCounts_args();
        args.AuthenticationToken = authenticationToken;
        args.Filter = filter;
        args.WithTrash = withTrash;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public NoteCollectionCounts recv_findNoteCounts()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        findNoteCounts_result result = new findNoteCounts_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "findNoteCounts failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNote(AsyncCallback callback, object state, string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      {
        return send_getNote(callback, state, authenticationToken, guid, withContent, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
      }

      public Evernote.EDAM.Type.Note End_getNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNote();
      }

      #endif
      public Evernote.EDAM.Type.Note getNote(string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNote(authenticationToken, guid, withContent, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
        return recv_getNote();

        #else
        var asyncResult = Begin_getNote(null, null, authenticationToken, guid, withContent, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
        return End_getNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNote(AsyncCallback callback, object state, string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      #else
      public void send_getNote(string authenticationToken, string guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNote", TMessageType.Call, seqid_));
        getNote_args args = new getNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.WithContent = withContent;
        args.WithResourcesData = withResourcesData;
        args.WithResourcesRecognition = withResourcesRecognition;
        args.WithResourcesAlternateData = withResourcesAlternateData;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Note recv_getNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNote_result result = new getNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getNoteApplicationData(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.LazyMap End_getNoteApplicationData(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteApplicationData();
      }

      #endif
      public Evernote.EDAM.Type.LazyMap getNoteApplicationData(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteApplicationData(authenticationToken, guid);
        return recv_getNoteApplicationData();

        #else
        var asyncResult = Begin_getNoteApplicationData(null, null, authenticationToken, guid);
        return End_getNoteApplicationData(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getNoteApplicationData(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteApplicationData", TMessageType.Call, seqid_));
        getNoteApplicationData_args args = new getNoteApplicationData_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.LazyMap recv_getNoteApplicationData()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteApplicationData_result result = new getNoteApplicationData_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteApplicationData failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      {
        return send_getNoteApplicationDataEntry(callback, state, authenticationToken, guid, key);
      }

      public string End_getNoteApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteApplicationDataEntry();
      }

      #endif
      public string getNoteApplicationDataEntry(string authenticationToken, string guid, string key)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteApplicationDataEntry(authenticationToken, guid, key);
        return recv_getNoteApplicationDataEntry();

        #else
        var asyncResult = Begin_getNoteApplicationDataEntry(null, null, authenticationToken, guid, key);
        return End_getNoteApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      #else
      public void send_getNoteApplicationDataEntry(string authenticationToken, string guid, string key)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteApplicationDataEntry", TMessageType.Call, seqid_));
        getNoteApplicationDataEntry_args args = new getNoteApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_getNoteApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteApplicationDataEntry_result result = new getNoteApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_setNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value)
      {
        return send_setNoteApplicationDataEntry(callback, state, authenticationToken, guid, key, value);
      }

      public int End_setNoteApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_setNoteApplicationDataEntry();
      }

      #endif
      public int setNoteApplicationDataEntry(string authenticationToken, string guid, string key, string value)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_setNoteApplicationDataEntry(authenticationToken, guid, key, value);
        return recv_setNoteApplicationDataEntry();

        #else
        var asyncResult = Begin_setNoteApplicationDataEntry(null, null, authenticationToken, guid, key, value);
        return End_setNoteApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_setNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value)
      #else
      public void send_setNoteApplicationDataEntry(string authenticationToken, string guid, string key, string value)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("setNoteApplicationDataEntry", TMessageType.Call, seqid_));
        setNoteApplicationDataEntry_args args = new setNoteApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Value = value;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_setNoteApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        setNoteApplicationDataEntry_result result = new setNoteApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setNoteApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_unsetNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      {
        return send_unsetNoteApplicationDataEntry(callback, state, authenticationToken, guid, key);
      }

      public int End_unsetNoteApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_unsetNoteApplicationDataEntry();
      }

      #endif
      public int unsetNoteApplicationDataEntry(string authenticationToken, string guid, string key)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_unsetNoteApplicationDataEntry(authenticationToken, guid, key);
        return recv_unsetNoteApplicationDataEntry();

        #else
        var asyncResult = Begin_unsetNoteApplicationDataEntry(null, null, authenticationToken, guid, key);
        return End_unsetNoteApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_unsetNoteApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      #else
      public void send_unsetNoteApplicationDataEntry(string authenticationToken, string guid, string key)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("unsetNoteApplicationDataEntry", TMessageType.Call, seqid_));
        unsetNoteApplicationDataEntry_args args = new unsetNoteApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_unsetNoteApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        unsetNoteApplicationDataEntry_result result = new unsetNoteApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "unsetNoteApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteContent(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getNoteContent(callback, state, authenticationToken, guid);
      }

      public string End_getNoteContent(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteContent();
      }

      #endif
      public string getNoteContent(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteContent(authenticationToken, guid);
        return recv_getNoteContent();

        #else
        var asyncResult = Begin_getNoteContent(null, null, authenticationToken, guid);
        return End_getNoteContent(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteContent(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getNoteContent(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteContent", TMessageType.Call, seqid_));
        getNoteContent_args args = new getNoteContent_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_getNoteContent()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteContent_result result = new getNoteContent_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteContent failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteSearchText(AsyncCallback callback, object state, string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing)
      {
        return send_getNoteSearchText(callback, state, authenticationToken, guid, noteOnly, tokenizeForIndexing);
      }

      public string End_getNoteSearchText(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteSearchText();
      }

      #endif
      public string getNoteSearchText(string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteSearchText(authenticationToken, guid, noteOnly, tokenizeForIndexing);
        return recv_getNoteSearchText();

        #else
        var asyncResult = Begin_getNoteSearchText(null, null, authenticationToken, guid, noteOnly, tokenizeForIndexing);
        return End_getNoteSearchText(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteSearchText(AsyncCallback callback, object state, string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing)
      #else
      public void send_getNoteSearchText(string authenticationToken, string guid, bool noteOnly, bool tokenizeForIndexing)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteSearchText", TMessageType.Call, seqid_));
        getNoteSearchText_args args = new getNoteSearchText_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.NoteOnly = noteOnly;
        args.TokenizeForIndexing = tokenizeForIndexing;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_getNoteSearchText()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteSearchText_result result = new getNoteSearchText_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteSearchText failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceSearchText(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceSearchText(callback, state, authenticationToken, guid);
      }

      public string End_getResourceSearchText(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceSearchText();
      }

      #endif
      public string getResourceSearchText(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceSearchText(authenticationToken, guid);
        return recv_getResourceSearchText();

        #else
        var asyncResult = Begin_getResourceSearchText(null, null, authenticationToken, guid);
        return End_getResourceSearchText(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceSearchText(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceSearchText(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceSearchText", TMessageType.Call, seqid_));
        getResourceSearchText_args args = new getResourceSearchText_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_getResourceSearchText()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceSearchText_result result = new getResourceSearchText_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceSearchText failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteTagNames(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getNoteTagNames(callback, state, authenticationToken, guid);
      }

      public List<string> End_getNoteTagNames(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteTagNames();
      }

      #endif
      public List<string> getNoteTagNames(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteTagNames(authenticationToken, guid);
        return recv_getNoteTagNames();

        #else
        var asyncResult = Begin_getNoteTagNames(null, null, authenticationToken, guid);
        return End_getNoteTagNames(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteTagNames(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getNoteTagNames(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteTagNames", TMessageType.Call, seqid_));
        getNoteTagNames_args args = new getNoteTagNames_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<string> recv_getNoteTagNames()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteTagNames_result result = new getNoteTagNames_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteTagNames failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note)
      {
        return send_createNote(callback, state, authenticationToken, note);
      }

      public Evernote.EDAM.Type.Note End_createNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createNote();
      }

      #endif
      public Evernote.EDAM.Type.Note createNote(string authenticationToken, Evernote.EDAM.Type.Note note)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createNote(authenticationToken, note);
        return recv_createNote();

        #else
        var asyncResult = Begin_createNote(null, null, authenticationToken, note);
        return End_createNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note)
      #else
      public void send_createNote(string authenticationToken, Evernote.EDAM.Type.Note note)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createNote", TMessageType.Call, seqid_));
        createNote_args args = new createNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Note = note;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Note recv_createNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createNote_result result = new createNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note)
      {
        return send_updateNote(callback, state, authenticationToken, note);
      }

      public Evernote.EDAM.Type.Note End_updateNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateNote();
      }

      #endif
      public Evernote.EDAM.Type.Note updateNote(string authenticationToken, Evernote.EDAM.Type.Note note)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateNote(authenticationToken, note);
        return recv_updateNote();

        #else
        var asyncResult = Begin_updateNote(null, null, authenticationToken, note);
        return End_updateNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateNote(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Note note)
      #else
      public void send_updateNote(string authenticationToken, Evernote.EDAM.Type.Note note)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateNote", TMessageType.Call, seqid_));
        updateNote_args args = new updateNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Note = note;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Note recv_updateNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateNote_result result = new updateNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_deleteNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_deleteNote(callback, state, authenticationToken, guid);
      }

      public int End_deleteNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_deleteNote();
      }

      #endif
      public int deleteNote(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_deleteNote(authenticationToken, guid);
        return recv_deleteNote();

        #else
        var asyncResult = Begin_deleteNote(null, null, authenticationToken, guid);
        return End_deleteNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_deleteNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_deleteNote(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("deleteNote", TMessageType.Call, seqid_));
        deleteNote_args args = new deleteNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_deleteNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        deleteNote_result result = new deleteNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "deleteNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_expungeNote(callback, state, authenticationToken, guid);
      }

      public int End_expungeNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeNote();
      }

      #endif
      public int expungeNote(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeNote(authenticationToken, guid);
        return recv_expungeNote();

        #else
        var asyncResult = Begin_expungeNote(null, null, authenticationToken, guid);
        return End_expungeNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_expungeNote(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeNote", TMessageType.Call, seqid_));
        expungeNote_args args = new expungeNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeNote_result result = new expungeNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeNotes(AsyncCallback callback, object state, string authenticationToken, List<string> noteGuids)
      {
        return send_expungeNotes(callback, state, authenticationToken, noteGuids);
      }

      public int End_expungeNotes(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeNotes();
      }

      #endif
      public int expungeNotes(string authenticationToken, List<string> noteGuids)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeNotes(authenticationToken, noteGuids);
        return recv_expungeNotes();

        #else
        var asyncResult = Begin_expungeNotes(null, null, authenticationToken, noteGuids);
        return End_expungeNotes(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeNotes(AsyncCallback callback, object state, string authenticationToken, List<string> noteGuids)
      #else
      public void send_expungeNotes(string authenticationToken, List<string> noteGuids)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeNotes", TMessageType.Call, seqid_));
        expungeNotes_args args = new expungeNotes_args();
        args.AuthenticationToken = authenticationToken;
        args.NoteGuids = noteGuids;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeNotes()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeNotes_result result = new expungeNotes_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeNotes failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeInactiveNotes(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_expungeInactiveNotes(callback, state, authenticationToken);
      }

      public int End_expungeInactiveNotes(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeInactiveNotes();
      }

      #endif
      public int expungeInactiveNotes(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeInactiveNotes(authenticationToken);
        return recv_expungeInactiveNotes();

        #else
        var asyncResult = Begin_expungeInactiveNotes(null, null, authenticationToken);
        return End_expungeInactiveNotes(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeInactiveNotes(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_expungeInactiveNotes(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeInactiveNotes", TMessageType.Call, seqid_));
        expungeInactiveNotes_args args = new expungeInactiveNotes_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeInactiveNotes()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeInactiveNotes_result result = new expungeInactiveNotes_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeInactiveNotes failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_copyNote(AsyncCallback callback, object state, string authenticationToken, string noteGuid, string toNotebookGuid)
      {
        return send_copyNote(callback, state, authenticationToken, noteGuid, toNotebookGuid);
      }

      public Evernote.EDAM.Type.Note End_copyNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_copyNote();
      }

      #endif
      public Evernote.EDAM.Type.Note copyNote(string authenticationToken, string noteGuid, string toNotebookGuid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_copyNote(authenticationToken, noteGuid, toNotebookGuid);
        return recv_copyNote();

        #else
        var asyncResult = Begin_copyNote(null, null, authenticationToken, noteGuid, toNotebookGuid);
        return End_copyNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_copyNote(AsyncCallback callback, object state, string authenticationToken, string noteGuid, string toNotebookGuid)
      #else
      public void send_copyNote(string authenticationToken, string noteGuid, string toNotebookGuid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("copyNote", TMessageType.Call, seqid_));
        copyNote_args args = new copyNote_args();
        args.AuthenticationToken = authenticationToken;
        args.NoteGuid = noteGuid;
        args.ToNotebookGuid = toNotebookGuid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Note recv_copyNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        copyNote_result result = new copyNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "copyNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listNoteVersions(AsyncCallback callback, object state, string authenticationToken, string noteGuid)
      {
        return send_listNoteVersions(callback, state, authenticationToken, noteGuid);
      }

      public List<NoteVersionId> End_listNoteVersions(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listNoteVersions();
      }

      #endif
      public List<NoteVersionId> listNoteVersions(string authenticationToken, string noteGuid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listNoteVersions(authenticationToken, noteGuid);
        return recv_listNoteVersions();

        #else
        var asyncResult = Begin_listNoteVersions(null, null, authenticationToken, noteGuid);
        return End_listNoteVersions(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listNoteVersions(AsyncCallback callback, object state, string authenticationToken, string noteGuid)
      #else
      public void send_listNoteVersions(string authenticationToken, string noteGuid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listNoteVersions", TMessageType.Call, seqid_));
        listNoteVersions_args args = new listNoteVersions_args();
        args.AuthenticationToken = authenticationToken;
        args.NoteGuid = noteGuid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<NoteVersionId> recv_listNoteVersions()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listNoteVersions_result result = new listNoteVersions_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listNoteVersions failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getNoteVersion(AsyncCallback callback, object state, string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      {
        return send_getNoteVersion(callback, state, authenticationToken, noteGuid, updateSequenceNum, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
      }

      public Evernote.EDAM.Type.Note End_getNoteVersion(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getNoteVersion();
      }

      #endif
      public Evernote.EDAM.Type.Note getNoteVersion(string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getNoteVersion(authenticationToken, noteGuid, updateSequenceNum, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
        return recv_getNoteVersion();

        #else
        var asyncResult = Begin_getNoteVersion(null, null, authenticationToken, noteGuid, updateSequenceNum, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
        return End_getNoteVersion(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getNoteVersion(AsyncCallback callback, object state, string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      #else
      public void send_getNoteVersion(string authenticationToken, string noteGuid, int updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getNoteVersion", TMessageType.Call, seqid_));
        getNoteVersion_args args = new getNoteVersion_args();
        args.AuthenticationToken = authenticationToken;
        args.NoteGuid = noteGuid;
        args.UpdateSequenceNum = updateSequenceNum;
        args.WithResourcesData = withResourcesData;
        args.WithResourcesRecognition = withResourcesRecognition;
        args.WithResourcesAlternateData = withResourcesAlternateData;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Note recv_getNoteVersion()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getNoteVersion_result result = new getNoteVersion_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getNoteVersion failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResource(AsyncCallback callback, object state, string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData)
      {
        return send_getResource(callback, state, authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData);
      }

      public Evernote.EDAM.Type.Resource End_getResource(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResource();
      }

      #endif
      public Evernote.EDAM.Type.Resource getResource(string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResource(authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData);
        return recv_getResource();

        #else
        var asyncResult = Begin_getResource(null, null, authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData);
        return End_getResource(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResource(AsyncCallback callback, object state, string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData)
      #else
      public void send_getResource(string authenticationToken, string guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResource", TMessageType.Call, seqid_));
        getResource_args args = new getResource_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.WithData = withData;
        args.WithRecognition = withRecognition;
        args.WithAttributes = withAttributes;
        args.WithAlternateData = withAlternateData;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Resource recv_getResource()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResource_result result = new getResource_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResource failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceApplicationData(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.LazyMap End_getResourceApplicationData(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceApplicationData();
      }

      #endif
      public Evernote.EDAM.Type.LazyMap getResourceApplicationData(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceApplicationData(authenticationToken, guid);
        return recv_getResourceApplicationData();

        #else
        var asyncResult = Begin_getResourceApplicationData(null, null, authenticationToken, guid);
        return End_getResourceApplicationData(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceApplicationData(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceApplicationData(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceApplicationData", TMessageType.Call, seqid_));
        getResourceApplicationData_args args = new getResourceApplicationData_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.LazyMap recv_getResourceApplicationData()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceApplicationData_result result = new getResourceApplicationData_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceApplicationData failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      {
        return send_getResourceApplicationDataEntry(callback, state, authenticationToken, guid, key);
      }

      public string End_getResourceApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceApplicationDataEntry();
      }

      #endif
      public string getResourceApplicationDataEntry(string authenticationToken, string guid, string key)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceApplicationDataEntry(authenticationToken, guid, key);
        return recv_getResourceApplicationDataEntry();

        #else
        var asyncResult = Begin_getResourceApplicationDataEntry(null, null, authenticationToken, guid, key);
        return End_getResourceApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      #else
      public void send_getResourceApplicationDataEntry(string authenticationToken, string guid, string key)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceApplicationDataEntry", TMessageType.Call, seqid_));
        getResourceApplicationDataEntry_args args = new getResourceApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_getResourceApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceApplicationDataEntry_result result = new getResourceApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_setResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value)
      {
        return send_setResourceApplicationDataEntry(callback, state, authenticationToken, guid, key, value);
      }

      public int End_setResourceApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_setResourceApplicationDataEntry();
      }

      #endif
      public int setResourceApplicationDataEntry(string authenticationToken, string guid, string key, string value)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_setResourceApplicationDataEntry(authenticationToken, guid, key, value);
        return recv_setResourceApplicationDataEntry();

        #else
        var asyncResult = Begin_setResourceApplicationDataEntry(null, null, authenticationToken, guid, key, value);
        return End_setResourceApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_setResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key, string value)
      #else
      public void send_setResourceApplicationDataEntry(string authenticationToken, string guid, string key, string value)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("setResourceApplicationDataEntry", TMessageType.Call, seqid_));
        setResourceApplicationDataEntry_args args = new setResourceApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Value = value;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_setResourceApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        setResourceApplicationDataEntry_result result = new setResourceApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setResourceApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_unsetResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      {
        return send_unsetResourceApplicationDataEntry(callback, state, authenticationToken, guid, key);
      }

      public int End_unsetResourceApplicationDataEntry(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_unsetResourceApplicationDataEntry();
      }

      #endif
      public int unsetResourceApplicationDataEntry(string authenticationToken, string guid, string key)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_unsetResourceApplicationDataEntry(authenticationToken, guid, key);
        return recv_unsetResourceApplicationDataEntry();

        #else
        var asyncResult = Begin_unsetResourceApplicationDataEntry(null, null, authenticationToken, guid, key);
        return End_unsetResourceApplicationDataEntry(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_unsetResourceApplicationDataEntry(AsyncCallback callback, object state, string authenticationToken, string guid, string key)
      #else
      public void send_unsetResourceApplicationDataEntry(string authenticationToken, string guid, string key)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("unsetResourceApplicationDataEntry", TMessageType.Call, seqid_));
        unsetResourceApplicationDataEntry_args args = new unsetResourceApplicationDataEntry_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Key = key;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_unsetResourceApplicationDataEntry()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        unsetResourceApplicationDataEntry_result result = new unsetResourceApplicationDataEntry_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "unsetResourceApplicationDataEntry failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateResource(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Resource resource)
      {
        return send_updateResource(callback, state, authenticationToken, resource);
      }

      public int End_updateResource(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateResource();
      }

      #endif
      public int updateResource(string authenticationToken, Evernote.EDAM.Type.Resource resource)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateResource(authenticationToken, resource);
        return recv_updateResource();

        #else
        var asyncResult = Begin_updateResource(null, null, authenticationToken, resource);
        return End_updateResource(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateResource(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.Resource resource)
      #else
      public void send_updateResource(string authenticationToken, Evernote.EDAM.Type.Resource resource)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateResource", TMessageType.Call, seqid_));
        updateResource_args args = new updateResource_args();
        args.AuthenticationToken = authenticationToken;
        args.Resource = resource;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateResource()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateResource_result result = new updateResource_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateResource failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceData(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceData(callback, state, authenticationToken, guid);
      }

      public byte[] End_getResourceData(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceData();
      }

      #endif
      public byte[] getResourceData(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceData(authenticationToken, guid);
        return recv_getResourceData();

        #else
        var asyncResult = Begin_getResourceData(null, null, authenticationToken, guid);
        return End_getResourceData(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceData(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceData(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceData", TMessageType.Call, seqid_));
        getResourceData_args args = new getResourceData_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public byte[] recv_getResourceData()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceData_result result = new getResourceData_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceData failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceByHash(AsyncCallback callback, object state, string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData)
      {
        return send_getResourceByHash(callback, state, authenticationToken, noteGuid, contentHash, withData, withRecognition, withAlternateData);
      }

      public Evernote.EDAM.Type.Resource End_getResourceByHash(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceByHash();
      }

      #endif
      public Evernote.EDAM.Type.Resource getResourceByHash(string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceByHash(authenticationToken, noteGuid, contentHash, withData, withRecognition, withAlternateData);
        return recv_getResourceByHash();

        #else
        var asyncResult = Begin_getResourceByHash(null, null, authenticationToken, noteGuid, contentHash, withData, withRecognition, withAlternateData);
        return End_getResourceByHash(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceByHash(AsyncCallback callback, object state, string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData)
      #else
      public void send_getResourceByHash(string authenticationToken, string noteGuid, byte[] contentHash, bool withData, bool withRecognition, bool withAlternateData)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceByHash", TMessageType.Call, seqid_));
        getResourceByHash_args args = new getResourceByHash_args();
        args.AuthenticationToken = authenticationToken;
        args.NoteGuid = noteGuid;
        args.ContentHash = contentHash;
        args.WithData = withData;
        args.WithRecognition = withRecognition;
        args.WithAlternateData = withAlternateData;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Resource recv_getResourceByHash()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceByHash_result result = new getResourceByHash_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceByHash failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceRecognition(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceRecognition(callback, state, authenticationToken, guid);
      }

      public byte[] End_getResourceRecognition(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceRecognition();
      }

      #endif
      public byte[] getResourceRecognition(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceRecognition(authenticationToken, guid);
        return recv_getResourceRecognition();

        #else
        var asyncResult = Begin_getResourceRecognition(null, null, authenticationToken, guid);
        return End_getResourceRecognition(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceRecognition(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceRecognition(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceRecognition", TMessageType.Call, seqid_));
        getResourceRecognition_args args = new getResourceRecognition_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public byte[] recv_getResourceRecognition()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceRecognition_result result = new getResourceRecognition_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceRecognition failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceAlternateData(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceAlternateData(callback, state, authenticationToken, guid);
      }

      public byte[] End_getResourceAlternateData(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceAlternateData();
      }

      #endif
      public byte[] getResourceAlternateData(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceAlternateData(authenticationToken, guid);
        return recv_getResourceAlternateData();

        #else
        var asyncResult = Begin_getResourceAlternateData(null, null, authenticationToken, guid);
        return End_getResourceAlternateData(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceAlternateData(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceAlternateData(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceAlternateData", TMessageType.Call, seqid_));
        getResourceAlternateData_args args = new getResourceAlternateData_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public byte[] recv_getResourceAlternateData()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceAlternateData_result result = new getResourceAlternateData_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceAlternateData failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getResourceAttributes(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_getResourceAttributes(callback, state, authenticationToken, guid);
      }

      public Evernote.EDAM.Type.ResourceAttributes End_getResourceAttributes(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getResourceAttributes();
      }

      #endif
      public Evernote.EDAM.Type.ResourceAttributes getResourceAttributes(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getResourceAttributes(authenticationToken, guid);
        return recv_getResourceAttributes();

        #else
        var asyncResult = Begin_getResourceAttributes(null, null, authenticationToken, guid);
        return End_getResourceAttributes(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getResourceAttributes(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_getResourceAttributes(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getResourceAttributes", TMessageType.Call, seqid_));
        getResourceAttributes_args args = new getResourceAttributes_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.ResourceAttributes recv_getResourceAttributes()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getResourceAttributes_result result = new getResourceAttributes_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getResourceAttributes failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getPublicNotebook(AsyncCallback callback, object state, int userId, string publicUri)
      {
        return send_getPublicNotebook(callback, state, userId, publicUri);
      }

      public Evernote.EDAM.Type.Notebook End_getPublicNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getPublicNotebook();
      }

      #endif
      public Evernote.EDAM.Type.Notebook getPublicNotebook(int userId, string publicUri)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getPublicNotebook(userId, publicUri);
        return recv_getPublicNotebook();

        #else
        var asyncResult = Begin_getPublicNotebook(null, null, userId, publicUri);
        return End_getPublicNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getPublicNotebook(AsyncCallback callback, object state, int userId, string publicUri)
      #else
      public void send_getPublicNotebook(int userId, string publicUri)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getPublicNotebook", TMessageType.Call, seqid_));
        getPublicNotebook_args args = new getPublicNotebook_args();
        args.UserId = userId;
        args.PublicUri = publicUri;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.Notebook recv_getPublicNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getPublicNotebook_result result = new getPublicNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getPublicNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      {
        return send_createSharedNotebook(callback, state, authenticationToken, sharedNotebook);
      }

      public Evernote.EDAM.Type.SharedNotebook End_createSharedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createSharedNotebook();
      }

      #endif
      public Evernote.EDAM.Type.SharedNotebook createSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createSharedNotebook(authenticationToken, sharedNotebook);
        return recv_createSharedNotebook();

        #else
        var asyncResult = Begin_createSharedNotebook(null, null, authenticationToken, sharedNotebook);
        return End_createSharedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      #else
      public void send_createSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createSharedNotebook", TMessageType.Call, seqid_));
        createSharedNotebook_args args = new createSharedNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.SharedNotebook = sharedNotebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.SharedNotebook recv_createSharedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createSharedNotebook_result result = new createSharedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createSharedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      {
        return send_updateSharedNotebook(callback, state, authenticationToken, sharedNotebook);
      }

      public int End_updateSharedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateSharedNotebook();
      }

      #endif
      public int updateSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateSharedNotebook(authenticationToken, sharedNotebook);
        return recv_updateSharedNotebook();

        #else
        var asyncResult = Begin_updateSharedNotebook(null, null, authenticationToken, sharedNotebook);
        return End_updateSharedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateSharedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      #else
      public void send_updateSharedNotebook(string authenticationToken, Evernote.EDAM.Type.SharedNotebook sharedNotebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateSharedNotebook", TMessageType.Call, seqid_));
        updateSharedNotebook_args args = new updateSharedNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.SharedNotebook = sharedNotebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateSharedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateSharedNotebook_result result = new updateSharedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateSharedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_setSharedNotebookRecipientSettings(AsyncCallback callback, object state, string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings)
      {
        return send_setSharedNotebookRecipientSettings(callback, state, authenticationToken, sharedNotebookId, recipientSettings);
      }

      public int End_setSharedNotebookRecipientSettings(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_setSharedNotebookRecipientSettings();
      }

      #endif
      public int setSharedNotebookRecipientSettings(string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_setSharedNotebookRecipientSettings(authenticationToken, sharedNotebookId, recipientSettings);
        return recv_setSharedNotebookRecipientSettings();

        #else
        var asyncResult = Begin_setSharedNotebookRecipientSettings(null, null, authenticationToken, sharedNotebookId, recipientSettings);
        return End_setSharedNotebookRecipientSettings(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_setSharedNotebookRecipientSettings(AsyncCallback callback, object state, string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings)
      #else
      public void send_setSharedNotebookRecipientSettings(string authenticationToken, long sharedNotebookId, Evernote.EDAM.Type.SharedNotebookRecipientSettings recipientSettings)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("setSharedNotebookRecipientSettings", TMessageType.Call, seqid_));
        setSharedNotebookRecipientSettings_args args = new setSharedNotebookRecipientSettings_args();
        args.AuthenticationToken = authenticationToken;
        args.SharedNotebookId = sharedNotebookId;
        args.RecipientSettings = recipientSettings;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_setSharedNotebookRecipientSettings()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        setSharedNotebookRecipientSettings_result result = new setSharedNotebookRecipientSettings_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "setSharedNotebookRecipientSettings failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_sendMessageToSharedNotebookMembers(AsyncCallback callback, object state, string authenticationToken, string notebookGuid, string messageText, List<string> recipients)
      {
        return send_sendMessageToSharedNotebookMembers(callback, state, authenticationToken, notebookGuid, messageText, recipients);
      }

      public int End_sendMessageToSharedNotebookMembers(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_sendMessageToSharedNotebookMembers();
      }

      #endif
      public int sendMessageToSharedNotebookMembers(string authenticationToken, string notebookGuid, string messageText, List<string> recipients)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_sendMessageToSharedNotebookMembers(authenticationToken, notebookGuid, messageText, recipients);
        return recv_sendMessageToSharedNotebookMembers();

        #else
        var asyncResult = Begin_sendMessageToSharedNotebookMembers(null, null, authenticationToken, notebookGuid, messageText, recipients);
        return End_sendMessageToSharedNotebookMembers(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_sendMessageToSharedNotebookMembers(AsyncCallback callback, object state, string authenticationToken, string notebookGuid, string messageText, List<string> recipients)
      #else
      public void send_sendMessageToSharedNotebookMembers(string authenticationToken, string notebookGuid, string messageText, List<string> recipients)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("sendMessageToSharedNotebookMembers", TMessageType.Call, seqid_));
        sendMessageToSharedNotebookMembers_args args = new sendMessageToSharedNotebookMembers_args();
        args.AuthenticationToken = authenticationToken;
        args.NotebookGuid = notebookGuid;
        args.MessageText = messageText;
        args.Recipients = recipients;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_sendMessageToSharedNotebookMembers()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        sendMessageToSharedNotebookMembers_result result = new sendMessageToSharedNotebookMembers_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "sendMessageToSharedNotebookMembers failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listSharedNotebooks(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_listSharedNotebooks(callback, state, authenticationToken);
      }

      public List<Evernote.EDAM.Type.SharedNotebook> End_listSharedNotebooks(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listSharedNotebooks();
      }

      #endif
      public List<Evernote.EDAM.Type.SharedNotebook> listSharedNotebooks(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listSharedNotebooks(authenticationToken);
        return recv_listSharedNotebooks();

        #else
        var asyncResult = Begin_listSharedNotebooks(null, null, authenticationToken);
        return End_listSharedNotebooks(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listSharedNotebooks(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_listSharedNotebooks(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listSharedNotebooks", TMessageType.Call, seqid_));
        listSharedNotebooks_args args = new listSharedNotebooks_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.SharedNotebook> recv_listSharedNotebooks()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listSharedNotebooks_result result = new listSharedNotebooks_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listSharedNotebooks failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeSharedNotebooks(AsyncCallback callback, object state, string authenticationToken, List<long> sharedNotebookIds)
      {
        return send_expungeSharedNotebooks(callback, state, authenticationToken, sharedNotebookIds);
      }

      public int End_expungeSharedNotebooks(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeSharedNotebooks();
      }

      #endif
      public int expungeSharedNotebooks(string authenticationToken, List<long> sharedNotebookIds)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeSharedNotebooks(authenticationToken, sharedNotebookIds);
        return recv_expungeSharedNotebooks();

        #else
        var asyncResult = Begin_expungeSharedNotebooks(null, null, authenticationToken, sharedNotebookIds);
        return End_expungeSharedNotebooks(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeSharedNotebooks(AsyncCallback callback, object state, string authenticationToken, List<long> sharedNotebookIds)
      #else
      public void send_expungeSharedNotebooks(string authenticationToken, List<long> sharedNotebookIds)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeSharedNotebooks", TMessageType.Call, seqid_));
        expungeSharedNotebooks_args args = new expungeSharedNotebooks_args();
        args.AuthenticationToken = authenticationToken;
        args.SharedNotebookIds = sharedNotebookIds;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeSharedNotebooks()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeSharedNotebooks_result result = new expungeSharedNotebooks_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeSharedNotebooks failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_createLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        return send_createLinkedNotebook(callback, state, authenticationToken, linkedNotebook);
      }

      public Evernote.EDAM.Type.LinkedNotebook End_createLinkedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_createLinkedNotebook();
      }

      #endif
      public Evernote.EDAM.Type.LinkedNotebook createLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_createLinkedNotebook(authenticationToken, linkedNotebook);
        return recv_createLinkedNotebook();

        #else
        var asyncResult = Begin_createLinkedNotebook(null, null, authenticationToken, linkedNotebook);
        return End_createLinkedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_createLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #else
      public void send_createLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("createLinkedNotebook", TMessageType.Call, seqid_));
        createLinkedNotebook_args args = new createLinkedNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.LinkedNotebook = linkedNotebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.LinkedNotebook recv_createLinkedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        createLinkedNotebook_result result = new createLinkedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "createLinkedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_updateLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        return send_updateLinkedNotebook(callback, state, authenticationToken, linkedNotebook);
      }

      public int End_updateLinkedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_updateLinkedNotebook();
      }

      #endif
      public int updateLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_updateLinkedNotebook(authenticationToken, linkedNotebook);
        return recv_updateLinkedNotebook();

        #else
        var asyncResult = Begin_updateLinkedNotebook(null, null, authenticationToken, linkedNotebook);
        return End_updateLinkedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_updateLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #else
      public void send_updateLinkedNotebook(string authenticationToken, Evernote.EDAM.Type.LinkedNotebook linkedNotebook)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("updateLinkedNotebook", TMessageType.Call, seqid_));
        updateLinkedNotebook_args args = new updateLinkedNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.LinkedNotebook = linkedNotebook;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_updateLinkedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        updateLinkedNotebook_result result = new updateLinkedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "updateLinkedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_listLinkedNotebooks(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_listLinkedNotebooks(callback, state, authenticationToken);
      }

      public List<Evernote.EDAM.Type.LinkedNotebook> End_listLinkedNotebooks(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_listLinkedNotebooks();
      }

      #endif
      public List<Evernote.EDAM.Type.LinkedNotebook> listLinkedNotebooks(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_listLinkedNotebooks(authenticationToken);
        return recv_listLinkedNotebooks();

        #else
        var asyncResult = Begin_listLinkedNotebooks(null, null, authenticationToken);
        return End_listLinkedNotebooks(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_listLinkedNotebooks(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_listLinkedNotebooks(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("listLinkedNotebooks", TMessageType.Call, seqid_));
        listLinkedNotebooks_args args = new listLinkedNotebooks_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public List<Evernote.EDAM.Type.LinkedNotebook> recv_listLinkedNotebooks()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        listLinkedNotebooks_result result = new listLinkedNotebooks_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "listLinkedNotebooks failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_expungeLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_expungeLinkedNotebook(callback, state, authenticationToken, guid);
      }

      public int End_expungeLinkedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_expungeLinkedNotebook();
      }

      #endif
      public int expungeLinkedNotebook(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_expungeLinkedNotebook(authenticationToken, guid);
        return recv_expungeLinkedNotebook();

        #else
        var asyncResult = Begin_expungeLinkedNotebook(null, null, authenticationToken, guid);
        return End_expungeLinkedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_expungeLinkedNotebook(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_expungeLinkedNotebook(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("expungeLinkedNotebook", TMessageType.Call, seqid_));
        expungeLinkedNotebook_args args = new expungeLinkedNotebook_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public int recv_expungeLinkedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        expungeLinkedNotebook_result result = new expungeLinkedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "expungeLinkedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_authenticateToSharedNotebook(AsyncCallback callback, object state, string shareKey, string authenticationToken)
      {
        return send_authenticateToSharedNotebook(callback, state, shareKey, authenticationToken);
      }

      public Evernote.EDAM.UserStore.AuthenticationResult End_authenticateToSharedNotebook(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_authenticateToSharedNotebook();
      }

      #endif
      public Evernote.EDAM.UserStore.AuthenticationResult authenticateToSharedNotebook(string shareKey, string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_authenticateToSharedNotebook(shareKey, authenticationToken);
        return recv_authenticateToSharedNotebook();

        #else
        var asyncResult = Begin_authenticateToSharedNotebook(null, null, shareKey, authenticationToken);
        return End_authenticateToSharedNotebook(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_authenticateToSharedNotebook(AsyncCallback callback, object state, string shareKey, string authenticationToken)
      #else
      public void send_authenticateToSharedNotebook(string shareKey, string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("authenticateToSharedNotebook", TMessageType.Call, seqid_));
        authenticateToSharedNotebook_args args = new authenticateToSharedNotebook_args();
        args.ShareKey = shareKey;
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.UserStore.AuthenticationResult recv_authenticateToSharedNotebook()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        authenticateToSharedNotebook_result result = new authenticateToSharedNotebook_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "authenticateToSharedNotebook failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_getSharedNotebookByAuth(AsyncCallback callback, object state, string authenticationToken)
      {
        return send_getSharedNotebookByAuth(callback, state, authenticationToken);
      }

      public Evernote.EDAM.Type.SharedNotebook End_getSharedNotebookByAuth(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_getSharedNotebookByAuth();
      }

      #endif
      public Evernote.EDAM.Type.SharedNotebook getSharedNotebookByAuth(string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_getSharedNotebookByAuth(authenticationToken);
        return recv_getSharedNotebookByAuth();

        #else
        var asyncResult = Begin_getSharedNotebookByAuth(null, null, authenticationToken);
        return End_getSharedNotebookByAuth(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_getSharedNotebookByAuth(AsyncCallback callback, object state, string authenticationToken)
      #else
      public void send_getSharedNotebookByAuth(string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("getSharedNotebookByAuth", TMessageType.Call, seqid_));
        getSharedNotebookByAuth_args args = new getSharedNotebookByAuth_args();
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.Type.SharedNotebook recv_getSharedNotebookByAuth()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        getSharedNotebookByAuth_result result = new getSharedNotebookByAuth_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "getSharedNotebookByAuth failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_emailNote(AsyncCallback callback, object state, string authenticationToken, NoteEmailParameters parameters)
      {
        return send_emailNote(callback, state, authenticationToken, parameters);
      }

      public void End_emailNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        recv_emailNote();
      }

      #endif
      public void emailNote(string authenticationToken, NoteEmailParameters parameters)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_emailNote(authenticationToken, parameters);
        recv_emailNote();

        #else
        var asyncResult = Begin_emailNote(null, null, authenticationToken, parameters);
        End_emailNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_emailNote(AsyncCallback callback, object state, string authenticationToken, NoteEmailParameters parameters)
      #else
      public void send_emailNote(string authenticationToken, NoteEmailParameters parameters)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("emailNote", TMessageType.Call, seqid_));
        emailNote_args args = new emailNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Parameters = parameters;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public void recv_emailNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        emailNote_result result = new emailNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        return;
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_shareNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_shareNote(callback, state, authenticationToken, guid);
      }

      public string End_shareNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_shareNote();
      }

      #endif
      public string shareNote(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_shareNote(authenticationToken, guid);
        return recv_shareNote();

        #else
        var asyncResult = Begin_shareNote(null, null, authenticationToken, guid);
        return End_shareNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_shareNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_shareNote(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("shareNote", TMessageType.Call, seqid_));
        shareNote_args args = new shareNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public string recv_shareNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        shareNote_result result = new shareNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "shareNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_stopSharingNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      {
        return send_stopSharingNote(callback, state, authenticationToken, guid);
      }

      public void End_stopSharingNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        recv_stopSharingNote();
      }

      #endif
      public void stopSharingNote(string authenticationToken, string guid)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_stopSharingNote(authenticationToken, guid);
        recv_stopSharingNote();

        #else
        var asyncResult = Begin_stopSharingNote(null, null, authenticationToken, guid);
        End_stopSharingNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_stopSharingNote(AsyncCallback callback, object state, string authenticationToken, string guid)
      #else
      public void send_stopSharingNote(string authenticationToken, string guid)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("stopSharingNote", TMessageType.Call, seqid_));
        stopSharingNote_args args = new stopSharingNote_args();
        args.AuthenticationToken = authenticationToken;
        args.Guid = guid;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public void recv_stopSharingNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        stopSharingNote_result result = new stopSharingNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        return;
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_authenticateToSharedNote(AsyncCallback callback, object state, string guid, string noteKey, string authenticationToken)
      {
        return send_authenticateToSharedNote(callback, state, guid, noteKey, authenticationToken);
      }

      public Evernote.EDAM.UserStore.AuthenticationResult End_authenticateToSharedNote(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_authenticateToSharedNote();
      }

      #endif
      public Evernote.EDAM.UserStore.AuthenticationResult authenticateToSharedNote(string guid, string noteKey, string authenticationToken)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_authenticateToSharedNote(guid, noteKey, authenticationToken);
        return recv_authenticateToSharedNote();

        #else
        var asyncResult = Begin_authenticateToSharedNote(null, null, guid, noteKey, authenticationToken);
        return End_authenticateToSharedNote(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_authenticateToSharedNote(AsyncCallback callback, object state, string guid, string noteKey, string authenticationToken)
      #else
      public void send_authenticateToSharedNote(string guid, string noteKey, string authenticationToken)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("authenticateToSharedNote", TMessageType.Call, seqid_));
        authenticateToSharedNote_args args = new authenticateToSharedNote_args();
        args.Guid = guid;
        args.NoteKey = noteKey;
        args.AuthenticationToken = authenticationToken;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public Evernote.EDAM.UserStore.AuthenticationResult recv_authenticateToSharedNote()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        authenticateToSharedNote_result result = new authenticateToSharedNote_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "authenticateToSharedNote failed: unknown result");
      }

      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult Begin_findRelated(AsyncCallback callback, object state, string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec)
      {
        return send_findRelated(callback, state, authenticationToken, query, resultSpec);
      }

      public RelatedResult End_findRelated(IAsyncResult asyncResult)
      {
        oprot_.Transport.EndFlush(asyncResult);
        return recv_findRelated();
      }

      #endif
      public RelatedResult findRelated(string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec)
      {
        #if !SILVERLIGHT && !NETFX_CORE
        send_findRelated(authenticationToken, query, resultSpec);
        return recv_findRelated();

        #else
        var asyncResult = Begin_findRelated(null, null, authenticationToken, query, resultSpec);
        return End_findRelated(asyncResult);

        #endif
      }
      #if SILVERLIGHT || NETFX_CORE
      public IAsyncResult send_findRelated(AsyncCallback callback, object state, string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec)
      #else
      public void send_findRelated(string authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec)
      #endif
      {
        oprot_.WriteMessageBegin(new TMessage("findRelated", TMessageType.Call, seqid_));
        findRelated_args args = new findRelated_args();
        args.AuthenticationToken = authenticationToken;
        args.Query = query;
        args.ResultSpec = resultSpec;
        args.Write(oprot_);
        oprot_.WriteMessageEnd();
        #if SILVERLIGHT || NETFX_CORE
        return oprot_.Transport.BeginFlush(callback, state);
        #else
        oprot_.Transport.Flush();
        #endif
      }

      public RelatedResult recv_findRelated()
      {
        TMessage msg = iprot_.ReadMessageBegin();
        if (msg.Type == TMessageType.Exception) {
          TApplicationException x = TApplicationException.Read(iprot_);
          iprot_.ReadMessageEnd();
          throw x;
        }
        findRelated_result result = new findRelated_result();
        result.Read(iprot_);
        iprot_.ReadMessageEnd();
        if (result.__isset.success) {
          return result.Success;
        }
        if (result.__isset.userException) {
          throw result.UserException;
        }
        if (result.__isset.systemException) {
          throw result.SystemException;
        }
        if (result.__isset.notFoundException) {
          throw result.NotFoundException;
        }
        throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "findRelated failed: unknown result");
      }

    }
    public class Processor : TProcessor {
      public Processor(Iface iface)
      {
        iface_ = iface;
        processMap_["getSyncState"] = getSyncState_Process;
        processMap_["getSyncStateWithMetrics"] = getSyncStateWithMetrics_Process;
        processMap_["getSyncChunk"] = getSyncChunk_Process;
        processMap_["getFilteredSyncChunk"] = getFilteredSyncChunk_Process;
        processMap_["getLinkedNotebookSyncState"] = getLinkedNotebookSyncState_Process;
        processMap_["getLinkedNotebookSyncChunk"] = getLinkedNotebookSyncChunk_Process;
        processMap_["listNotebooks"] = listNotebooks_Process;
        processMap_["getNotebook"] = getNotebook_Process;
        processMap_["getDefaultNotebook"] = getDefaultNotebook_Process;
        processMap_["createNotebook"] = createNotebook_Process;
        processMap_["updateNotebook"] = updateNotebook_Process;
        processMap_["expungeNotebook"] = expungeNotebook_Process;
        processMap_["listTags"] = listTags_Process;
        processMap_["listTagsByNotebook"] = listTagsByNotebook_Process;
        processMap_["getTag"] = getTag_Process;
        processMap_["createTag"] = createTag_Process;
        processMap_["updateTag"] = updateTag_Process;
        processMap_["untagAll"] = untagAll_Process;
        processMap_["expungeTag"] = expungeTag_Process;
        processMap_["listSearches"] = listSearches_Process;
        processMap_["getSearch"] = getSearch_Process;
        processMap_["createSearch"] = createSearch_Process;
        processMap_["updateSearch"] = updateSearch_Process;
        processMap_["expungeSearch"] = expungeSearch_Process;
        processMap_["findNotes"] = findNotes_Process;
        processMap_["findNoteOffset"] = findNoteOffset_Process;
        processMap_["findNotesMetadata"] = findNotesMetadata_Process;
        processMap_["findNoteCounts"] = findNoteCounts_Process;
        processMap_["getNote"] = getNote_Process;
        processMap_["getNoteApplicationData"] = getNoteApplicationData_Process;
        processMap_["getNoteApplicationDataEntry"] = getNoteApplicationDataEntry_Process;
        processMap_["setNoteApplicationDataEntry"] = setNoteApplicationDataEntry_Process;
        processMap_["unsetNoteApplicationDataEntry"] = unsetNoteApplicationDataEntry_Process;
        processMap_["getNoteContent"] = getNoteContent_Process;
        processMap_["getNoteSearchText"] = getNoteSearchText_Process;
        processMap_["getResourceSearchText"] = getResourceSearchText_Process;
        processMap_["getNoteTagNames"] = getNoteTagNames_Process;
        processMap_["createNote"] = createNote_Process;
        processMap_["updateNote"] = updateNote_Process;
        processMap_["deleteNote"] = deleteNote_Process;
        processMap_["expungeNote"] = expungeNote_Process;
        processMap_["expungeNotes"] = expungeNotes_Process;
        processMap_["expungeInactiveNotes"] = expungeInactiveNotes_Process;
        processMap_["copyNote"] = copyNote_Process;
        processMap_["listNoteVersions"] = listNoteVersions_Process;
        processMap_["getNoteVersion"] = getNoteVersion_Process;
        processMap_["getResource"] = getResource_Process;
        processMap_["getResourceApplicationData"] = getResourceApplicationData_Process;
        processMap_["getResourceApplicationDataEntry"] = getResourceApplicationDataEntry_Process;
        processMap_["setResourceApplicationDataEntry"] = setResourceApplicationDataEntry_Process;
        processMap_["unsetResourceApplicationDataEntry"] = unsetResourceApplicationDataEntry_Process;
        processMap_["updateResource"] = updateResource_Process;
        processMap_["getResourceData"] = getResourceData_Process;
        processMap_["getResourceByHash"] = getResourceByHash_Process;
        processMap_["getResourceRecognition"] = getResourceRecognition_Process;
        processMap_["getResourceAlternateData"] = getResourceAlternateData_Process;
        processMap_["getResourceAttributes"] = getResourceAttributes_Process;
        processMap_["getPublicNotebook"] = getPublicNotebook_Process;
        processMap_["createSharedNotebook"] = createSharedNotebook_Process;
        processMap_["updateSharedNotebook"] = updateSharedNotebook_Process;
        processMap_["setSharedNotebookRecipientSettings"] = setSharedNotebookRecipientSettings_Process;
        processMap_["sendMessageToSharedNotebookMembers"] = sendMessageToSharedNotebookMembers_Process;
        processMap_["listSharedNotebooks"] = listSharedNotebooks_Process;
        processMap_["expungeSharedNotebooks"] = expungeSharedNotebooks_Process;
        processMap_["createLinkedNotebook"] = createLinkedNotebook_Process;
        processMap_["updateLinkedNotebook"] = updateLinkedNotebook_Process;
        processMap_["listLinkedNotebooks"] = listLinkedNotebooks_Process;
        processMap_["expungeLinkedNotebook"] = expungeLinkedNotebook_Process;
        processMap_["authenticateToSharedNotebook"] = authenticateToSharedNotebook_Process;
        processMap_["getSharedNotebookByAuth"] = getSharedNotebookByAuth_Process;
        processMap_["emailNote"] = emailNote_Process;
        processMap_["shareNote"] = shareNote_Process;
        processMap_["stopSharingNote"] = stopSharingNote_Process;
        processMap_["authenticateToSharedNote"] = authenticateToSharedNote_Process;
        processMap_["findRelated"] = findRelated_Process;
      }

      protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);
      private Iface iface_;
      protected Dictionary<string, ProcessFunction> processMap_ = new Dictionary<string, ProcessFunction>();

      public bool Process(TProtocol iprot, TProtocol oprot)
      {
        try
        {
          TMessage msg = iprot.ReadMessageBegin();
          ProcessFunction fn;
          processMap_.TryGetValue(msg.Name, out fn);
          if (fn == null) {
            TProtocolUtil.Skip(iprot, TType.Struct);
            iprot.ReadMessageEnd();
            TApplicationException x = new TApplicationException (TApplicationException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
            oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));
            x.Write(oprot);
            oprot.WriteMessageEnd();
            oprot.Transport.Flush();
            return true;
          }
          fn(msg.SeqID, iprot, oprot);
        }
        catch (IOException)
        {
          return false;
        }
        return true;
      }

      public void getSyncState_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getSyncState_args args = new getSyncState_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getSyncState_result result = new getSyncState_result();
        try {
          result.Success = iface_.getSyncState(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getSyncState", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getSyncStateWithMetrics_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getSyncStateWithMetrics_args args = new getSyncStateWithMetrics_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getSyncStateWithMetrics_result result = new getSyncStateWithMetrics_result();
        try {
          result.Success = iface_.getSyncStateWithMetrics(args.AuthenticationToken, args.ClientMetrics);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getSyncStateWithMetrics", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getSyncChunk_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getSyncChunk_args args = new getSyncChunk_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getSyncChunk_result result = new getSyncChunk_result();
        try {
          result.Success = iface_.getSyncChunk(args.AuthenticationToken, args.AfterUSN, args.MaxEntries, args.FullSyncOnly);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getSyncChunk", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getFilteredSyncChunk_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getFilteredSyncChunk_args args = new getFilteredSyncChunk_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getFilteredSyncChunk_result result = new getFilteredSyncChunk_result();
        try {
          result.Success = iface_.getFilteredSyncChunk(args.AuthenticationToken, args.AfterUSN, args.MaxEntries, args.Filter);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getFilteredSyncChunk", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getLinkedNotebookSyncState_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getLinkedNotebookSyncState_args args = new getLinkedNotebookSyncState_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getLinkedNotebookSyncState_result result = new getLinkedNotebookSyncState_result();
        try {
          result.Success = iface_.getLinkedNotebookSyncState(args.AuthenticationToken, args.LinkedNotebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getLinkedNotebookSyncState", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getLinkedNotebookSyncChunk_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getLinkedNotebookSyncChunk_args args = new getLinkedNotebookSyncChunk_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getLinkedNotebookSyncChunk_result result = new getLinkedNotebookSyncChunk_result();
        try {
          result.Success = iface_.getLinkedNotebookSyncChunk(args.AuthenticationToken, args.LinkedNotebook, args.AfterUSN, args.MaxEntries, args.FullSyncOnly);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getLinkedNotebookSyncChunk", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listNotebooks_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listNotebooks_args args = new listNotebooks_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listNotebooks_result result = new listNotebooks_result();
        try {
          result.Success = iface_.listNotebooks(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("listNotebooks", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNotebook_args args = new getNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNotebook_result result = new getNotebook_result();
        try {
          result.Success = iface_.getNotebook(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getDefaultNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getDefaultNotebook_args args = new getDefaultNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getDefaultNotebook_result result = new getDefaultNotebook_result();
        try {
          result.Success = iface_.getDefaultNotebook(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getDefaultNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createNotebook_args args = new createNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createNotebook_result result = new createNotebook_result();
        try {
          result.Success = iface_.createNotebook(args.AuthenticationToken, args.Notebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("createNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateNotebook_args args = new updateNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateNotebook_result result = new updateNotebook_result();
        try {
          result.Success = iface_.updateNotebook(args.AuthenticationToken, args.Notebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("updateNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeNotebook_args args = new expungeNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeNotebook_result result = new expungeNotebook_result();
        try {
          result.Success = iface_.expungeNotebook(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listTags_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listTags_args args = new listTags_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listTags_result result = new listTags_result();
        try {
          result.Success = iface_.listTags(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("listTags", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listTagsByNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listTagsByNotebook_args args = new listTagsByNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listTagsByNotebook_result result = new listTagsByNotebook_result();
        try {
          result.Success = iface_.listTagsByNotebook(args.AuthenticationToken, args.NotebookGuid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("listTagsByNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getTag_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getTag_args args = new getTag_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getTag_result result = new getTag_result();
        try {
          result.Success = iface_.getTag(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getTag", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createTag_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createTag_args args = new createTag_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createTag_result result = new createTag_result();
        try {
          result.Success = iface_.createTag(args.AuthenticationToken, args.Tag);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("createTag", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateTag_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateTag_args args = new updateTag_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateTag_result result = new updateTag_result();
        try {
          result.Success = iface_.updateTag(args.AuthenticationToken, args.Tag);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("updateTag", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void untagAll_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        untagAll_args args = new untagAll_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        untagAll_result result = new untagAll_result();
        try {
          iface_.untagAll(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("untagAll", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeTag_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeTag_args args = new expungeTag_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeTag_result result = new expungeTag_result();
        try {
          result.Success = iface_.expungeTag(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeTag", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listSearches_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listSearches_args args = new listSearches_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listSearches_result result = new listSearches_result();
        try {
          result.Success = iface_.listSearches(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("listSearches", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getSearch_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getSearch_args args = new getSearch_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getSearch_result result = new getSearch_result();
        try {
          result.Success = iface_.getSearch(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getSearch", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createSearch_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createSearch_args args = new createSearch_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createSearch_result result = new createSearch_result();
        try {
          result.Success = iface_.createSearch(args.AuthenticationToken, args.Search);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("createSearch", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateSearch_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateSearch_args args = new updateSearch_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateSearch_result result = new updateSearch_result();
        try {
          result.Success = iface_.updateSearch(args.AuthenticationToken, args.Search);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("updateSearch", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeSearch_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeSearch_args args = new expungeSearch_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeSearch_result result = new expungeSearch_result();
        try {
          result.Success = iface_.expungeSearch(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeSearch", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void findNotes_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        findNotes_args args = new findNotes_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        findNotes_result result = new findNotes_result();
        try {
          result.Success = iface_.findNotes(args.AuthenticationToken, args.Filter, args.Offset, args.MaxNotes);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("findNotes", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void findNoteOffset_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        findNoteOffset_args args = new findNoteOffset_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        findNoteOffset_result result = new findNoteOffset_result();
        try {
          result.Success = iface_.findNoteOffset(args.AuthenticationToken, args.Filter, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("findNoteOffset", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void findNotesMetadata_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        findNotesMetadata_args args = new findNotesMetadata_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        findNotesMetadata_result result = new findNotesMetadata_result();
        try {
          result.Success = iface_.findNotesMetadata(args.AuthenticationToken, args.Filter, args.Offset, args.MaxNotes, args.ResultSpec);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("findNotesMetadata", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void findNoteCounts_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        findNoteCounts_args args = new findNoteCounts_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        findNoteCounts_result result = new findNoteCounts_result();
        try {
          result.Success = iface_.findNoteCounts(args.AuthenticationToken, args.Filter, args.WithTrash);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("findNoteCounts", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNote_args args = new getNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNote_result result = new getNote_result();
        try {
          result.Success = iface_.getNote(args.AuthenticationToken, args.Guid, args.WithContent, args.WithResourcesData, args.WithResourcesRecognition, args.WithResourcesAlternateData);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteApplicationData_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteApplicationData_args args = new getNoteApplicationData_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteApplicationData_result result = new getNoteApplicationData_result();
        try {
          result.Success = iface_.getNoteApplicationData(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteApplicationData", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteApplicationDataEntry_args args = new getNoteApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteApplicationDataEntry_result result = new getNoteApplicationDataEntry_result();
        try {
          result.Success = iface_.getNoteApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void setNoteApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        setNoteApplicationDataEntry_args args = new setNoteApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        setNoteApplicationDataEntry_result result = new setNoteApplicationDataEntry_result();
        try {
          result.Success = iface_.setNoteApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key, args.Value);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("setNoteApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void unsetNoteApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        unsetNoteApplicationDataEntry_args args = new unsetNoteApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        unsetNoteApplicationDataEntry_result result = new unsetNoteApplicationDataEntry_result();
        try {
          result.Success = iface_.unsetNoteApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("unsetNoteApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteContent_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteContent_args args = new getNoteContent_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteContent_result result = new getNoteContent_result();
        try {
          result.Success = iface_.getNoteContent(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteContent", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteSearchText_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteSearchText_args args = new getNoteSearchText_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteSearchText_result result = new getNoteSearchText_result();
        try {
          result.Success = iface_.getNoteSearchText(args.AuthenticationToken, args.Guid, args.NoteOnly, args.TokenizeForIndexing);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteSearchText", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceSearchText_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceSearchText_args args = new getResourceSearchText_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceSearchText_result result = new getResourceSearchText_result();
        try {
          result.Success = iface_.getResourceSearchText(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceSearchText", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteTagNames_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteTagNames_args args = new getNoteTagNames_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteTagNames_result result = new getNoteTagNames_result();
        try {
          result.Success = iface_.getNoteTagNames(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteTagNames", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createNote_args args = new createNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createNote_result result = new createNote_result();
        try {
          result.Success = iface_.createNote(args.AuthenticationToken, args.Note);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("createNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateNote_args args = new updateNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateNote_result result = new updateNote_result();
        try {
          result.Success = iface_.updateNote(args.AuthenticationToken, args.Note);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("updateNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void deleteNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        deleteNote_args args = new deleteNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        deleteNote_result result = new deleteNote_result();
        try {
          result.Success = iface_.deleteNote(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("deleteNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeNote_args args = new expungeNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeNote_result result = new expungeNote_result();
        try {
          result.Success = iface_.expungeNote(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeNotes_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeNotes_args args = new expungeNotes_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeNotes_result result = new expungeNotes_result();
        try {
          result.Success = iface_.expungeNotes(args.AuthenticationToken, args.NoteGuids);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeNotes", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeInactiveNotes_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeInactiveNotes_args args = new expungeInactiveNotes_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeInactiveNotes_result result = new expungeInactiveNotes_result();
        try {
          result.Success = iface_.expungeInactiveNotes(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeInactiveNotes", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void copyNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        copyNote_args args = new copyNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        copyNote_result result = new copyNote_result();
        try {
          result.Success = iface_.copyNote(args.AuthenticationToken, args.NoteGuid, args.ToNotebookGuid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("copyNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listNoteVersions_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listNoteVersions_args args = new listNoteVersions_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listNoteVersions_result result = new listNoteVersions_result();
        try {
          result.Success = iface_.listNoteVersions(args.AuthenticationToken, args.NoteGuid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("listNoteVersions", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getNoteVersion_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getNoteVersion_args args = new getNoteVersion_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getNoteVersion_result result = new getNoteVersion_result();
        try {
          result.Success = iface_.getNoteVersion(args.AuthenticationToken, args.NoteGuid, args.UpdateSequenceNum, args.WithResourcesData, args.WithResourcesRecognition, args.WithResourcesAlternateData);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getNoteVersion", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResource_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResource_args args = new getResource_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResource_result result = new getResource_result();
        try {
          result.Success = iface_.getResource(args.AuthenticationToken, args.Guid, args.WithData, args.WithRecognition, args.WithAttributes, args.WithAlternateData);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResource", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceApplicationData_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceApplicationData_args args = new getResourceApplicationData_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceApplicationData_result result = new getResourceApplicationData_result();
        try {
          result.Success = iface_.getResourceApplicationData(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceApplicationData", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceApplicationDataEntry_args args = new getResourceApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceApplicationDataEntry_result result = new getResourceApplicationDataEntry_result();
        try {
          result.Success = iface_.getResourceApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void setResourceApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        setResourceApplicationDataEntry_args args = new setResourceApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        setResourceApplicationDataEntry_result result = new setResourceApplicationDataEntry_result();
        try {
          result.Success = iface_.setResourceApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key, args.Value);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("setResourceApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void unsetResourceApplicationDataEntry_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        unsetResourceApplicationDataEntry_args args = new unsetResourceApplicationDataEntry_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        unsetResourceApplicationDataEntry_result result = new unsetResourceApplicationDataEntry_result();
        try {
          result.Success = iface_.unsetResourceApplicationDataEntry(args.AuthenticationToken, args.Guid, args.Key);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("unsetResourceApplicationDataEntry", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateResource_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateResource_args args = new updateResource_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateResource_result result = new updateResource_result();
        try {
          result.Success = iface_.updateResource(args.AuthenticationToken, args.Resource);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("updateResource", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceData_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceData_args args = new getResourceData_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceData_result result = new getResourceData_result();
        try {
          result.Success = iface_.getResourceData(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceData", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceByHash_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceByHash_args args = new getResourceByHash_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceByHash_result result = new getResourceByHash_result();
        try {
          result.Success = iface_.getResourceByHash(args.AuthenticationToken, args.NoteGuid, args.ContentHash, args.WithData, args.WithRecognition, args.WithAlternateData);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceByHash", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceRecognition_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceRecognition_args args = new getResourceRecognition_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceRecognition_result result = new getResourceRecognition_result();
        try {
          result.Success = iface_.getResourceRecognition(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceRecognition", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceAlternateData_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceAlternateData_args args = new getResourceAlternateData_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceAlternateData_result result = new getResourceAlternateData_result();
        try {
          result.Success = iface_.getResourceAlternateData(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceAlternateData", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getResourceAttributes_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getResourceAttributes_args args = new getResourceAttributes_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getResourceAttributes_result result = new getResourceAttributes_result();
        try {
          result.Success = iface_.getResourceAttributes(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getResourceAttributes", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getPublicNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getPublicNotebook_args args = new getPublicNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getPublicNotebook_result result = new getPublicNotebook_result();
        try {
          result.Success = iface_.getPublicNotebook(args.UserId, args.PublicUri);
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("getPublicNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createSharedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createSharedNotebook_args args = new createSharedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createSharedNotebook_result result = new createSharedNotebook_result();
        try {
          result.Success = iface_.createSharedNotebook(args.AuthenticationToken, args.SharedNotebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("createSharedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateSharedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateSharedNotebook_args args = new updateSharedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateSharedNotebook_result result = new updateSharedNotebook_result();
        try {
          result.Success = iface_.updateSharedNotebook(args.AuthenticationToken, args.SharedNotebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("updateSharedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void setSharedNotebookRecipientSettings_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        setSharedNotebookRecipientSettings_args args = new setSharedNotebookRecipientSettings_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        setSharedNotebookRecipientSettings_result result = new setSharedNotebookRecipientSettings_result();
        try {
          result.Success = iface_.setSharedNotebookRecipientSettings(args.AuthenticationToken, args.SharedNotebookId, args.RecipientSettings);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("setSharedNotebookRecipientSettings", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void sendMessageToSharedNotebookMembers_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        sendMessageToSharedNotebookMembers_args args = new sendMessageToSharedNotebookMembers_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        sendMessageToSharedNotebookMembers_result result = new sendMessageToSharedNotebookMembers_result();
        try {
          result.Success = iface_.sendMessageToSharedNotebookMembers(args.AuthenticationToken, args.NotebookGuid, args.MessageText, args.Recipients);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("sendMessageToSharedNotebookMembers", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listSharedNotebooks_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listSharedNotebooks_args args = new listSharedNotebooks_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listSharedNotebooks_result result = new listSharedNotebooks_result();
        try {
          result.Success = iface_.listSharedNotebooks(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("listSharedNotebooks", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeSharedNotebooks_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeSharedNotebooks_args args = new expungeSharedNotebooks_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeSharedNotebooks_result result = new expungeSharedNotebooks_result();
        try {
          result.Success = iface_.expungeSharedNotebooks(args.AuthenticationToken, args.SharedNotebookIds);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeSharedNotebooks", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void createLinkedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        createLinkedNotebook_args args = new createLinkedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        createLinkedNotebook_result result = new createLinkedNotebook_result();
        try {
          result.Success = iface_.createLinkedNotebook(args.AuthenticationToken, args.LinkedNotebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("createLinkedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void updateLinkedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        updateLinkedNotebook_args args = new updateLinkedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        updateLinkedNotebook_result result = new updateLinkedNotebook_result();
        try {
          result.Success = iface_.updateLinkedNotebook(args.AuthenticationToken, args.LinkedNotebook);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("updateLinkedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void listLinkedNotebooks_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        listLinkedNotebooks_args args = new listLinkedNotebooks_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        listLinkedNotebooks_result result = new listLinkedNotebooks_result();
        try {
          result.Success = iface_.listLinkedNotebooks(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("listLinkedNotebooks", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void expungeLinkedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        expungeLinkedNotebook_args args = new expungeLinkedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        expungeLinkedNotebook_result result = new expungeLinkedNotebook_result();
        try {
          result.Success = iface_.expungeLinkedNotebook(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("expungeLinkedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void authenticateToSharedNotebook_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        authenticateToSharedNotebook_args args = new authenticateToSharedNotebook_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        authenticateToSharedNotebook_result result = new authenticateToSharedNotebook_result();
        try {
          result.Success = iface_.authenticateToSharedNotebook(args.ShareKey, args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("authenticateToSharedNotebook", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void getSharedNotebookByAuth_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        getSharedNotebookByAuth_args args = new getSharedNotebookByAuth_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        getSharedNotebookByAuth_result result = new getSharedNotebookByAuth_result();
        try {
          result.Success = iface_.getSharedNotebookByAuth(args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("getSharedNotebookByAuth", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void emailNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        emailNote_args args = new emailNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        emailNote_result result = new emailNote_result();
        try {
          iface_.emailNote(args.AuthenticationToken, args.Parameters);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("emailNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void shareNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        shareNote_args args = new shareNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        shareNote_result result = new shareNote_result();
        try {
          result.Success = iface_.shareNote(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("shareNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void stopSharingNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        stopSharingNote_args args = new stopSharingNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        stopSharingNote_result result = new stopSharingNote_result();
        try {
          iface_.stopSharingNote(args.AuthenticationToken, args.Guid);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("stopSharingNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void authenticateToSharedNote_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        authenticateToSharedNote_args args = new authenticateToSharedNote_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        authenticateToSharedNote_result result = new authenticateToSharedNote_result();
        try {
          result.Success = iface_.authenticateToSharedNote(args.Guid, args.NoteKey, args.AuthenticationToken);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        }
        oprot.WriteMessageBegin(new TMessage("authenticateToSharedNote", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

      public void findRelated_Process(int seqid, TProtocol iprot, TProtocol oprot)
      {
        findRelated_args args = new findRelated_args();
        args.Read(iprot);
        iprot.ReadMessageEnd();
        findRelated_result result = new findRelated_result();
        try {
          result.Success = iface_.findRelated(args.AuthenticationToken, args.Query, args.ResultSpec);
        } catch (Evernote.EDAM.Error.EDAMUserException userException) {
          result.UserException = userException;
        } catch (Evernote.EDAM.Error.EDAMSystemException systemException) {
          result.SystemException = systemException;
        } catch (Evernote.EDAM.Error.EDAMNotFoundException notFoundException) {
          result.NotFoundException = notFoundException;
        }
        oprot.WriteMessageBegin(new TMessage("findRelated", TMessageType.Reply, seqid)); 
        result.Write(oprot);
        oprot.WriteMessageEnd();
        oprot.Transport.Flush();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncState_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public getSyncState_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncState_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncState_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncState_result : TBase
    {
      private SyncState _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public SyncState Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public getSyncState_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncState();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncState_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncState_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncStateWithMetrics_args : TBase
    {
      private string _authenticationToken;
      private ClientUsageMetrics _clientMetrics;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public ClientUsageMetrics ClientMetrics
      {
        get
        {
          return _clientMetrics;
        }
        set
        {
          __isset.clientMetrics = true;
          this._clientMetrics = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool clientMetrics;
      }

      public getSyncStateWithMetrics_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                ClientMetrics = new ClientUsageMetrics();
                ClientMetrics.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncStateWithMetrics_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (ClientMetrics != null && __isset.clientMetrics) {
          field.Name = "clientMetrics";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          ClientMetrics.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncStateWithMetrics_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",ClientMetrics: ");
        sb.Append(ClientMetrics== null ? "<null>" : ClientMetrics.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncStateWithMetrics_result : TBase
    {
      private SyncState _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public SyncState Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public getSyncStateWithMetrics_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncState();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncStateWithMetrics_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncStateWithMetrics_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncChunk_args : TBase
    {
      private string _authenticationToken;
      private int _afterUSN;
      private int _maxEntries;
      private bool _fullSyncOnly;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public int AfterUSN
      {
        get
        {
          return _afterUSN;
        }
        set
        {
          __isset.afterUSN = true;
          this._afterUSN = value;
        }
      }

      public int MaxEntries
      {
        get
        {
          return _maxEntries;
        }
        set
        {
          __isset.maxEntries = true;
          this._maxEntries = value;
        }
      }

      public bool FullSyncOnly
      {
        get
        {
          return _fullSyncOnly;
        }
        set
        {
          __isset.fullSyncOnly = true;
          this._fullSyncOnly = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool afterUSN;
        public bool maxEntries;
        public bool fullSyncOnly;
      }

      public getSyncChunk_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.I32) {
                AfterUSN = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                MaxEntries = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                FullSyncOnly = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncChunk_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (__isset.afterUSN) {
          field.Name = "afterUSN";
          field.Type = TType.I32;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(AfterUSN);
          oprot.WriteFieldEnd();
        }
        if (__isset.maxEntries) {
          field.Name = "maxEntries";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(MaxEntries);
          oprot.WriteFieldEnd();
        }
        if (__isset.fullSyncOnly) {
          field.Name = "fullSyncOnly";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(FullSyncOnly);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncChunk_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",AfterUSN: ");
        sb.Append(AfterUSN);
        sb.Append(",MaxEntries: ");
        sb.Append(MaxEntries);
        sb.Append(",FullSyncOnly: ");
        sb.Append(FullSyncOnly);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSyncChunk_result : TBase
    {
      private SyncChunk _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public SyncChunk Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public getSyncChunk_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncChunk();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSyncChunk_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSyncChunk_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getFilteredSyncChunk_args : TBase
    {
      private string _authenticationToken;
      private int _afterUSN;
      private int _maxEntries;
      private SyncChunkFilter _filter;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public int AfterUSN
      {
        get
        {
          return _afterUSN;
        }
        set
        {
          __isset.afterUSN = true;
          this._afterUSN = value;
        }
      }

      public int MaxEntries
      {
        get
        {
          return _maxEntries;
        }
        set
        {
          __isset.maxEntries = true;
          this._maxEntries = value;
        }
      }

      public SyncChunkFilter Filter
      {
        get
        {
          return _filter;
        }
        set
        {
          __isset.filter = true;
          this._filter = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool afterUSN;
        public bool maxEntries;
        public bool filter;
      }

      public getFilteredSyncChunk_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.I32) {
                AfterUSN = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                MaxEntries = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Struct) {
                Filter = new SyncChunkFilter();
                Filter.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getFilteredSyncChunk_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (__isset.afterUSN) {
          field.Name = "afterUSN";
          field.Type = TType.I32;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(AfterUSN);
          oprot.WriteFieldEnd();
        }
        if (__isset.maxEntries) {
          field.Name = "maxEntries";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(MaxEntries);
          oprot.WriteFieldEnd();
        }
        if (Filter != null && __isset.filter) {
          field.Name = "filter";
          field.Type = TType.Struct;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          Filter.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getFilteredSyncChunk_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",AfterUSN: ");
        sb.Append(AfterUSN);
        sb.Append(",MaxEntries: ");
        sb.Append(MaxEntries);
        sb.Append(",Filter: ");
        sb.Append(Filter== null ? "<null>" : Filter.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getFilteredSyncChunk_result : TBase
    {
      private SyncChunk _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public SyncChunk Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public getFilteredSyncChunk_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncChunk();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getFilteredSyncChunk_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getFilteredSyncChunk_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getLinkedNotebookSyncState_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.LinkedNotebook _linkedNotebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.LinkedNotebook LinkedNotebook
      {
        get
        {
          return _linkedNotebook;
        }
        set
        {
          __isset.linkedNotebook = true;
          this._linkedNotebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool linkedNotebook;
      }

      public getLinkedNotebookSyncState_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                LinkedNotebook = new Evernote.EDAM.Type.LinkedNotebook();
                LinkedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getLinkedNotebookSyncState_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (LinkedNotebook != null && __isset.linkedNotebook) {
          field.Name = "linkedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          LinkedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getLinkedNotebookSyncState_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",LinkedNotebook: ");
        sb.Append(LinkedNotebook== null ? "<null>" : LinkedNotebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getLinkedNotebookSyncState_result : TBase
    {
      private SyncState _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public SyncState Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getLinkedNotebookSyncState_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncState();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getLinkedNotebookSyncState_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getLinkedNotebookSyncState_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getLinkedNotebookSyncChunk_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.LinkedNotebook _linkedNotebook;
      private int _afterUSN;
      private int _maxEntries;
      private bool _fullSyncOnly;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.LinkedNotebook LinkedNotebook
      {
        get
        {
          return _linkedNotebook;
        }
        set
        {
          __isset.linkedNotebook = true;
          this._linkedNotebook = value;
        }
      }

      public int AfterUSN
      {
        get
        {
          return _afterUSN;
        }
        set
        {
          __isset.afterUSN = true;
          this._afterUSN = value;
        }
      }

      public int MaxEntries
      {
        get
        {
          return _maxEntries;
        }
        set
        {
          __isset.maxEntries = true;
          this._maxEntries = value;
        }
      }

      public bool FullSyncOnly
      {
        get
        {
          return _fullSyncOnly;
        }
        set
        {
          __isset.fullSyncOnly = true;
          this._fullSyncOnly = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool linkedNotebook;
        public bool afterUSN;
        public bool maxEntries;
        public bool fullSyncOnly;
      }

      public getLinkedNotebookSyncChunk_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                LinkedNotebook = new Evernote.EDAM.Type.LinkedNotebook();
                LinkedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                AfterUSN = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.I32) {
                MaxEntries = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Bool) {
                FullSyncOnly = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getLinkedNotebookSyncChunk_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (LinkedNotebook != null && __isset.linkedNotebook) {
          field.Name = "linkedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          LinkedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (__isset.afterUSN) {
          field.Name = "afterUSN";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(AfterUSN);
          oprot.WriteFieldEnd();
        }
        if (__isset.maxEntries) {
          field.Name = "maxEntries";
          field.Type = TType.I32;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(MaxEntries);
          oprot.WriteFieldEnd();
        }
        if (__isset.fullSyncOnly) {
          field.Name = "fullSyncOnly";
          field.Type = TType.Bool;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(FullSyncOnly);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getLinkedNotebookSyncChunk_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",LinkedNotebook: ");
        sb.Append(LinkedNotebook== null ? "<null>" : LinkedNotebook.ToString());
        sb.Append(",AfterUSN: ");
        sb.Append(AfterUSN);
        sb.Append(",MaxEntries: ");
        sb.Append(MaxEntries);
        sb.Append(",FullSyncOnly: ");
        sb.Append(FullSyncOnly);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getLinkedNotebookSyncChunk_result : TBase
    {
      private SyncChunk _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public SyncChunk Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getLinkedNotebookSyncChunk_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new SyncChunk();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getLinkedNotebookSyncChunk_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getLinkedNotebookSyncChunk_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listNotebooks_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public listNotebooks_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listNotebooks_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listNotebooks_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listNotebooks_result : TBase
    {
      private List<Evernote.EDAM.Type.Notebook> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public List<Evernote.EDAM.Type.Notebook> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public listNotebooks_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.Notebook>();
                  TList _list110 = iprot.ReadListBegin();
                  for( int _i111 = 0; _i111 < _list110.Count; ++_i111)
                  {
                    Evernote.EDAM.Type.Notebook _elem112 = new Evernote.EDAM.Type.Notebook();
                    _elem112 = new Evernote.EDAM.Type.Notebook();
                    _elem112.Read(iprot);
                    Success.Add(_elem112);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listNotebooks_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.Notebook _iter113 in Success)
              {
                _iter113.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listNotebooks_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNotebook_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNotebook_result : TBase
    {
      private Evernote.EDAM.Type.Notebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Notebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Notebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getDefaultNotebook_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public getDefaultNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getDefaultNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getDefaultNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getDefaultNotebook_result : TBase
    {
      private Evernote.EDAM.Type.Notebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.Notebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public getDefaultNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Notebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getDefaultNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getDefaultNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Notebook _notebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Notebook Notebook
      {
        get
        {
          return _notebook;
        }
        set
        {
          __isset.notebook = true;
          this._notebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool notebook;
      }

      public createNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Notebook = new Evernote.EDAM.Type.Notebook();
                Notebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Notebook != null && __isset.notebook) {
          field.Name = "notebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Notebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Notebook: ");
        sb.Append(Notebook== null ? "<null>" : Notebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createNotebook_result : TBase
    {
      private Evernote.EDAM.Type.Notebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.Notebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public createNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Notebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Notebook _notebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Notebook Notebook
      {
        get
        {
          return _notebook;
        }
        set
        {
          __isset.notebook = true;
          this._notebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool notebook;
      }

      public updateNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Notebook = new Evernote.EDAM.Type.Notebook();
                Notebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Notebook != null && __isset.notebook) {
          field.Name = "notebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Notebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Notebook: ");
        sb.Append(Notebook== null ? "<null>" : Notebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateNotebook_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public updateNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNotebook_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public expungeNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNotebook_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public expungeNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listTags_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public listTags_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listTags_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listTags_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listTags_result : TBase
    {
      private List<Evernote.EDAM.Type.Tag> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public List<Evernote.EDAM.Type.Tag> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public listTags_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.Tag>();
                  TList _list114 = iprot.ReadListBegin();
                  for( int _i115 = 0; _i115 < _list114.Count; ++_i115)
                  {
                    Evernote.EDAM.Type.Tag _elem116 = new Evernote.EDAM.Type.Tag();
                    _elem116 = new Evernote.EDAM.Type.Tag();
                    _elem116.Read(iprot);
                    Success.Add(_elem116);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listTags_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.Tag _iter117 in Success)
              {
                _iter117.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listTags_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listTagsByNotebook_args : TBase
    {
      private string _authenticationToken;
      private string _notebookGuid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NotebookGuid
      {
        get
        {
          return _notebookGuid;
        }
        set
        {
          __isset.notebookGuid = true;
          this._notebookGuid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool notebookGuid;
      }

      public listTagsByNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NotebookGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listTagsByNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NotebookGuid != null && __isset.notebookGuid) {
          field.Name = "notebookGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NotebookGuid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listTagsByNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NotebookGuid: ");
        sb.Append(NotebookGuid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listTagsByNotebook_result : TBase
    {
      private List<Evernote.EDAM.Type.Tag> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public List<Evernote.EDAM.Type.Tag> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public listTagsByNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.Tag>();
                  TList _list118 = iprot.ReadListBegin();
                  for( int _i119 = 0; _i119 < _list118.Count; ++_i119)
                  {
                    Evernote.EDAM.Type.Tag _elem120 = new Evernote.EDAM.Type.Tag();
                    _elem120 = new Evernote.EDAM.Type.Tag();
                    _elem120.Read(iprot);
                    Success.Add(_elem120);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listTagsByNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.Tag _iter121 in Success)
              {
                _iter121.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listTagsByNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getTag_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getTag_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getTag_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getTag_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getTag_result : TBase
    {
      private Evernote.EDAM.Type.Tag _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Tag Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getTag_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Tag();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getTag_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getTag_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createTag_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Tag _tag;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Tag Tag
      {
        get
        {
          return _tag;
        }
        set
        {
          __isset.tag = true;
          this._tag = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool tag;
      }

      public createTag_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Tag = new Evernote.EDAM.Type.Tag();
                Tag.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createTag_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Tag != null && __isset.tag) {
          field.Name = "tag";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Tag.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createTag_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Tag: ");
        sb.Append(Tag== null ? "<null>" : Tag.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createTag_result : TBase
    {
      private Evernote.EDAM.Type.Tag _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Tag Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public createTag_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Tag();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createTag_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createTag_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateTag_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Tag _tag;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Tag Tag
      {
        get
        {
          return _tag;
        }
        set
        {
          __isset.tag = true;
          this._tag = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool tag;
      }

      public updateTag_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Tag = new Evernote.EDAM.Type.Tag();
                Tag.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateTag_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Tag != null && __isset.tag) {
          field.Name = "tag";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Tag.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateTag_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Tag: ");
        sb.Append(Tag== null ? "<null>" : Tag.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateTag_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public updateTag_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateTag_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateTag_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class untagAll_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public untagAll_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("untagAll_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("untagAll_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class untagAll_result : TBase
    {
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public untagAll_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("untagAll_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("untagAll_result(");
        sb.Append("UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeTag_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public expungeTag_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeTag_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeTag_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeTag_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public expungeTag_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeTag_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeTag_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listSearches_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public listSearches_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listSearches_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listSearches_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listSearches_result : TBase
    {
      private List<Evernote.EDAM.Type.SavedSearch> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public List<Evernote.EDAM.Type.SavedSearch> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public listSearches_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.SavedSearch>();
                  TList _list122 = iprot.ReadListBegin();
                  for( int _i123 = 0; _i123 < _list122.Count; ++_i123)
                  {
                    Evernote.EDAM.Type.SavedSearch _elem124 = new Evernote.EDAM.Type.SavedSearch();
                    _elem124 = new Evernote.EDAM.Type.SavedSearch();
                    _elem124.Read(iprot);
                    Success.Add(_elem124);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listSearches_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.SavedSearch _iter125 in Success)
              {
                _iter125.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listSearches_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSearch_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getSearch_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSearch_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSearch_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSearch_result : TBase
    {
      private Evernote.EDAM.Type.SavedSearch _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.SavedSearch Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getSearch_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.SavedSearch();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSearch_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSearch_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createSearch_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.SavedSearch _search;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.SavedSearch Search
      {
        get
        {
          return _search;
        }
        set
        {
          __isset.search = true;
          this._search = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool search;
      }

      public createSearch_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Search = new Evernote.EDAM.Type.SavedSearch();
                Search.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createSearch_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Search != null && __isset.search) {
          field.Name = "search";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Search.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createSearch_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Search: ");
        sb.Append(Search== null ? "<null>" : Search.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createSearch_result : TBase
    {
      private Evernote.EDAM.Type.SavedSearch _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.SavedSearch Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public createSearch_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.SavedSearch();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createSearch_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createSearch_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateSearch_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.SavedSearch _search;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.SavedSearch Search
      {
        get
        {
          return _search;
        }
        set
        {
          __isset.search = true;
          this._search = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool search;
      }

      public updateSearch_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Search = new Evernote.EDAM.Type.SavedSearch();
                Search.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateSearch_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Search != null && __isset.search) {
          field.Name = "search";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Search.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateSearch_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Search: ");
        sb.Append(Search== null ? "<null>" : Search.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateSearch_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public updateSearch_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateSearch_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateSearch_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeSearch_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public expungeSearch_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeSearch_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeSearch_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeSearch_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public expungeSearch_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeSearch_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeSearch_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNotes_args : TBase
    {
      private string _authenticationToken;
      private NoteFilter _filter;
      private int _offset;
      private int _maxNotes;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public NoteFilter Filter
      {
        get
        {
          return _filter;
        }
        set
        {
          __isset.filter = true;
          this._filter = value;
        }
      }

      public int Offset
      {
        get
        {
          return _offset;
        }
        set
        {
          __isset.offset = true;
          this._offset = value;
        }
      }

      public int MaxNotes
      {
        get
        {
          return _maxNotes;
        }
        set
        {
          __isset.maxNotes = true;
          this._maxNotes = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool filter;
        public bool offset;
        public bool maxNotes;
      }

      public findNotes_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Filter = new NoteFilter();
                Filter.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                Offset = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.I32) {
                MaxNotes = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNotes_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Filter != null && __isset.filter) {
          field.Name = "filter";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Filter.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (__isset.offset) {
          field.Name = "offset";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Offset);
          oprot.WriteFieldEnd();
        }
        if (__isset.maxNotes) {
          field.Name = "maxNotes";
          field.Type = TType.I32;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(MaxNotes);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNotes_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Filter: ");
        sb.Append(Filter== null ? "<null>" : Filter.ToString());
        sb.Append(",Offset: ");
        sb.Append(Offset);
        sb.Append(",MaxNotes: ");
        sb.Append(MaxNotes);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNotes_result : TBase
    {
      private NoteList _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public NoteList Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public findNotes_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new NoteList();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNotes_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNotes_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNoteOffset_args : TBase
    {
      private string _authenticationToken;
      private NoteFilter _filter;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public NoteFilter Filter
      {
        get
        {
          return _filter;
        }
        set
        {
          __isset.filter = true;
          this._filter = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool filter;
        public bool guid;
      }

      public findNoteOffset_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Filter = new NoteFilter();
                Filter.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNoteOffset_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Filter != null && __isset.filter) {
          field.Name = "filter";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Filter.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNoteOffset_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Filter: ");
        sb.Append(Filter== null ? "<null>" : Filter.ToString());
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNoteOffset_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public findNoteOffset_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNoteOffset_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNoteOffset_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNotesMetadata_args : TBase
    {
      private string _authenticationToken;
      private NoteFilter _filter;
      private int _offset;
      private int _maxNotes;
      private NotesMetadataResultSpec _resultSpec;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public NoteFilter Filter
      {
        get
        {
          return _filter;
        }
        set
        {
          __isset.filter = true;
          this._filter = value;
        }
      }

      public int Offset
      {
        get
        {
          return _offset;
        }
        set
        {
          __isset.offset = true;
          this._offset = value;
        }
      }

      public int MaxNotes
      {
        get
        {
          return _maxNotes;
        }
        set
        {
          __isset.maxNotes = true;
          this._maxNotes = value;
        }
      }

      public NotesMetadataResultSpec ResultSpec
      {
        get
        {
          return _resultSpec;
        }
        set
        {
          __isset.resultSpec = true;
          this._resultSpec = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool filter;
        public bool offset;
        public bool maxNotes;
        public bool resultSpec;
      }

      public findNotesMetadata_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Filter = new NoteFilter();
                Filter.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                Offset = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.I32) {
                MaxNotes = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Struct) {
                ResultSpec = new NotesMetadataResultSpec();
                ResultSpec.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNotesMetadata_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Filter != null && __isset.filter) {
          field.Name = "filter";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Filter.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (__isset.offset) {
          field.Name = "offset";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Offset);
          oprot.WriteFieldEnd();
        }
        if (__isset.maxNotes) {
          field.Name = "maxNotes";
          field.Type = TType.I32;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(MaxNotes);
          oprot.WriteFieldEnd();
        }
        if (ResultSpec != null && __isset.resultSpec) {
          field.Name = "resultSpec";
          field.Type = TType.Struct;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          ResultSpec.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNotesMetadata_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Filter: ");
        sb.Append(Filter== null ? "<null>" : Filter.ToString());
        sb.Append(",Offset: ");
        sb.Append(Offset);
        sb.Append(",MaxNotes: ");
        sb.Append(MaxNotes);
        sb.Append(",ResultSpec: ");
        sb.Append(ResultSpec== null ? "<null>" : ResultSpec.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNotesMetadata_result : TBase
    {
      private NotesMetadataList _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public NotesMetadataList Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public findNotesMetadata_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new NotesMetadataList();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNotesMetadata_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNotesMetadata_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNoteCounts_args : TBase
    {
      private string _authenticationToken;
      private NoteFilter _filter;
      private bool _withTrash;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public NoteFilter Filter
      {
        get
        {
          return _filter;
        }
        set
        {
          __isset.filter = true;
          this._filter = value;
        }
      }

      public bool WithTrash
      {
        get
        {
          return _withTrash;
        }
        set
        {
          __isset.withTrash = true;
          this._withTrash = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool filter;
        public bool withTrash;
      }

      public findNoteCounts_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Filter = new NoteFilter();
                Filter.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Bool) {
                WithTrash = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNoteCounts_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Filter != null && __isset.filter) {
          field.Name = "filter";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Filter.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (__isset.withTrash) {
          field.Name = "withTrash";
          field.Type = TType.Bool;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithTrash);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNoteCounts_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Filter: ");
        sb.Append(Filter== null ? "<null>" : Filter.ToString());
        sb.Append(",WithTrash: ");
        sb.Append(WithTrash);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findNoteCounts_result : TBase
    {
      private NoteCollectionCounts _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public NoteCollectionCounts Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public findNoteCounts_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new NoteCollectionCounts();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findNoteCounts_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findNoteCounts_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNote_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private bool _withContent;
      private bool _withResourcesData;
      private bool _withResourcesRecognition;
      private bool _withResourcesAlternateData;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public bool WithContent
      {
        get
        {
          return _withContent;
        }
        set
        {
          __isset.withContent = true;
          this._withContent = value;
        }
      }

      public bool WithResourcesData
      {
        get
        {
          return _withResourcesData;
        }
        set
        {
          __isset.withResourcesData = true;
          this._withResourcesData = value;
        }
      }

      public bool WithResourcesRecognition
      {
        get
        {
          return _withResourcesRecognition;
        }
        set
        {
          __isset.withResourcesRecognition = true;
          this._withResourcesRecognition = value;
        }
      }

      public bool WithResourcesAlternateData
      {
        get
        {
          return _withResourcesAlternateData;
        }
        set
        {
          __isset.withResourcesAlternateData = true;
          this._withResourcesAlternateData = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool withContent;
        public bool withResourcesData;
        public bool withResourcesRecognition;
        public bool withResourcesAlternateData;
      }

      public getNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Bool) {
                WithContent = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                WithResourcesData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Bool) {
                WithResourcesRecognition = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 6:
              if (field.Type == TType.Bool) {
                WithResourcesAlternateData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (__isset.withContent) {
          field.Name = "withContent";
          field.Type = TType.Bool;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithContent);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesData) {
          field.Name = "withResourcesData";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesData);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesRecognition) {
          field.Name = "withResourcesRecognition";
          field.Type = TType.Bool;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesRecognition);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesAlternateData) {
          field.Name = "withResourcesAlternateData";
          field.Type = TType.Bool;
          field.ID = 6;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesAlternateData);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",WithContent: ");
        sb.Append(WithContent);
        sb.Append(",WithResourcesData: ");
        sb.Append(WithResourcesData);
        sb.Append(",WithResourcesRecognition: ");
        sb.Append(WithResourcesRecognition);
        sb.Append(",WithResourcesAlternateData: ");
        sb.Append(WithResourcesAlternateData);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNote_result : TBase
    {
      private Evernote.EDAM.Type.Note _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Note Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Note();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNote_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteApplicationData_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getNoteApplicationData_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteApplicationData_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteApplicationData_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteApplicationData_result : TBase
    {
      private Evernote.EDAM.Type.LazyMap _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.LazyMap Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteApplicationData_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.LazyMap();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteApplicationData_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteApplicationData_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
      }

      public getNoteApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteApplicationDataEntry_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setNoteApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;
      private string _value;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }

      public string Value
      {
        get
        {
          return _value;
        }
        set
        {
          __isset.value = true;
          this._value = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
        public bool value;
      }

      public setNoteApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.String) {
                Value = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setNoteApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        if (Value != null && __isset.value) {
          field.Name = "value";
          field.Type = TType.String;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Value);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setNoteApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(",Value: ");
        sb.Append(Value);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setNoteApplicationDataEntry_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public setNoteApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setNoteApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setNoteApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class unsetNoteApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
      }

      public unsetNoteApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("unsetNoteApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("unsetNoteApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class unsetNoteApplicationDataEntry_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public unsetNoteApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("unsetNoteApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("unsetNoteApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteContent_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getNoteContent_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteContent_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteContent_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteContent_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteContent_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteContent_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteContent_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteSearchText_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private bool _noteOnly;
      private bool _tokenizeForIndexing;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public bool NoteOnly
      {
        get
        {
          return _noteOnly;
        }
        set
        {
          __isset.noteOnly = true;
          this._noteOnly = value;
        }
      }

      public bool TokenizeForIndexing
      {
        get
        {
          return _tokenizeForIndexing;
        }
        set
        {
          __isset.tokenizeForIndexing = true;
          this._tokenizeForIndexing = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool noteOnly;
        public bool tokenizeForIndexing;
      }

      public getNoteSearchText_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Bool) {
                NoteOnly = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                TokenizeForIndexing = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteSearchText_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (__isset.noteOnly) {
          field.Name = "noteOnly";
          field.Type = TType.Bool;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(NoteOnly);
          oprot.WriteFieldEnd();
        }
        if (__isset.tokenizeForIndexing) {
          field.Name = "tokenizeForIndexing";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(TokenizeForIndexing);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteSearchText_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",NoteOnly: ");
        sb.Append(NoteOnly);
        sb.Append(",TokenizeForIndexing: ");
        sb.Append(TokenizeForIndexing);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteSearchText_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteSearchText_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteSearchText_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteSearchText_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceSearchText_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceSearchText_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceSearchText_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceSearchText_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceSearchText_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceSearchText_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceSearchText_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceSearchText_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteTagNames_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getNoteTagNames_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteTagNames_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteTagNames_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteTagNames_result : TBase
    {
      private List<string> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public List<string> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteTagNames_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<string>();
                  TList _list126 = iprot.ReadListBegin();
                  for( int _i127 = 0; _i127 < _list126.Count; ++_i127)
                  {
                    string _elem128 = null;
                    _elem128 = iprot.ReadString();
                    Success.Add(_elem128);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteTagNames_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.String, Success.Count));
              foreach (string _iter129 in Success)
              {
                oprot.WriteString(_iter129);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteTagNames_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createNote_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Note _note;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Note Note
      {
        get
        {
          return _note;
        }
        set
        {
          __isset.note = true;
          this._note = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool note;
      }

      public createNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Note = new Evernote.EDAM.Type.Note();
                Note.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Note != null && __isset.note) {
          field.Name = "note";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Note.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Note: ");
        sb.Append(Note== null ? "<null>" : Note.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createNote_result : TBase
    {
      private Evernote.EDAM.Type.Note _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Note Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public createNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Note();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createNote_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateNote_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Note _note;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Note Note
      {
        get
        {
          return _note;
        }
        set
        {
          __isset.note = true;
          this._note = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool note;
      }

      public updateNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Note = new Evernote.EDAM.Type.Note();
                Note.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Note != null && __isset.note) {
          field.Name = "note";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Note.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Note: ");
        sb.Append(Note== null ? "<null>" : Note.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateNote_result : TBase
    {
      private Evernote.EDAM.Type.Note _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Note Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public updateNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Note();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateNote_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class deleteNote_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public deleteNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("deleteNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("deleteNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class deleteNote_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public deleteNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("deleteNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("deleteNote_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNote_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public expungeNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNote_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public expungeNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNote_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNotes_args : TBase
    {
      private string _authenticationToken;
      private List<string> _noteGuids;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public List<string> NoteGuids
      {
        get
        {
          return _noteGuids;
        }
        set
        {
          __isset.noteGuids = true;
          this._noteGuids = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool noteGuids;
      }

      public expungeNotes_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.List) {
                {
                  NoteGuids = new List<string>();
                  TList _list130 = iprot.ReadListBegin();
                  for( int _i131 = 0; _i131 < _list130.Count; ++_i131)
                  {
                    string _elem132 = null;
                    _elem132 = iprot.ReadString();
                    NoteGuids.Add(_elem132);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNotes_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NoteGuids != null && __isset.noteGuids) {
          field.Name = "noteGuids";
          field.Type = TType.List;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          {
            oprot.WriteListBegin(new TList(TType.String, NoteGuids.Count));
            foreach (string _iter133 in NoteGuids)
            {
              oprot.WriteString(_iter133);
              oprot.WriteListEnd();
            }
          }
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNotes_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NoteGuids: ");
        sb.Append(NoteGuids);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeNotes_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public expungeNotes_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeNotes_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeNotes_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeInactiveNotes_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public expungeInactiveNotes_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeInactiveNotes_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeInactiveNotes_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeInactiveNotes_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
      }

      public expungeInactiveNotes_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeInactiveNotes_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeInactiveNotes_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class copyNote_args : TBase
    {
      private string _authenticationToken;
      private string _noteGuid;
      private string _toNotebookGuid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NoteGuid
      {
        get
        {
          return _noteGuid;
        }
        set
        {
          __isset.noteGuid = true;
          this._noteGuid = value;
        }
      }

      public string ToNotebookGuid
      {
        get
        {
          return _toNotebookGuid;
        }
        set
        {
          __isset.toNotebookGuid = true;
          this._toNotebookGuid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool noteGuid;
        public bool toNotebookGuid;
      }

      public copyNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NoteGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                ToNotebookGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("copyNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NoteGuid != null && __isset.noteGuid) {
          field.Name = "noteGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NoteGuid);
          oprot.WriteFieldEnd();
        }
        if (ToNotebookGuid != null && __isset.toNotebookGuid) {
          field.Name = "toNotebookGuid";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(ToNotebookGuid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("copyNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NoteGuid: ");
        sb.Append(NoteGuid);
        sb.Append(",ToNotebookGuid: ");
        sb.Append(ToNotebookGuid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class copyNote_result : TBase
    {
      private Evernote.EDAM.Type.Note _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Note Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public copyNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Note();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("copyNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("copyNote_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listNoteVersions_args : TBase
    {
      private string _authenticationToken;
      private string _noteGuid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NoteGuid
      {
        get
        {
          return _noteGuid;
        }
        set
        {
          __isset.noteGuid = true;
          this._noteGuid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool noteGuid;
      }

      public listNoteVersions_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NoteGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listNoteVersions_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NoteGuid != null && __isset.noteGuid) {
          field.Name = "noteGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NoteGuid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listNoteVersions_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NoteGuid: ");
        sb.Append(NoteGuid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listNoteVersions_result : TBase
    {
      private List<NoteVersionId> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public List<NoteVersionId> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public listNoteVersions_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<NoteVersionId>();
                  TList _list134 = iprot.ReadListBegin();
                  for( int _i135 = 0; _i135 < _list134.Count; ++_i135)
                  {
                    NoteVersionId _elem136 = new NoteVersionId();
                    _elem136 = new NoteVersionId();
                    _elem136.Read(iprot);
                    Success.Add(_elem136);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listNoteVersions_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (NoteVersionId _iter137 in Success)
              {
                _iter137.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listNoteVersions_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteVersion_args : TBase
    {
      private string _authenticationToken;
      private string _noteGuid;
      private int _updateSequenceNum;
      private bool _withResourcesData;
      private bool _withResourcesRecognition;
      private bool _withResourcesAlternateData;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NoteGuid
      {
        get
        {
          return _noteGuid;
        }
        set
        {
          __isset.noteGuid = true;
          this._noteGuid = value;
        }
      }

      public int UpdateSequenceNum
      {
        get
        {
          return _updateSequenceNum;
        }
        set
        {
          __isset.updateSequenceNum = true;
          this._updateSequenceNum = value;
        }
      }

      public bool WithResourcesData
      {
        get
        {
          return _withResourcesData;
        }
        set
        {
          __isset.withResourcesData = true;
          this._withResourcesData = value;
        }
      }

      public bool WithResourcesRecognition
      {
        get
        {
          return _withResourcesRecognition;
        }
        set
        {
          __isset.withResourcesRecognition = true;
          this._withResourcesRecognition = value;
        }
      }

      public bool WithResourcesAlternateData
      {
        get
        {
          return _withResourcesAlternateData;
        }
        set
        {
          __isset.withResourcesAlternateData = true;
          this._withResourcesAlternateData = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool noteGuid;
        public bool updateSequenceNum;
        public bool withResourcesData;
        public bool withResourcesRecognition;
        public bool withResourcesAlternateData;
      }

      public getNoteVersion_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NoteGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.I32) {
                UpdateSequenceNum = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                WithResourcesData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Bool) {
                WithResourcesRecognition = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 6:
              if (field.Type == TType.Bool) {
                WithResourcesAlternateData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteVersion_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NoteGuid != null && __isset.noteGuid) {
          field.Name = "noteGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NoteGuid);
          oprot.WriteFieldEnd();
        }
        if (__isset.updateSequenceNum) {
          field.Name = "updateSequenceNum";
          field.Type = TType.I32;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(UpdateSequenceNum);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesData) {
          field.Name = "withResourcesData";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesData);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesRecognition) {
          field.Name = "withResourcesRecognition";
          field.Type = TType.Bool;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesRecognition);
          oprot.WriteFieldEnd();
        }
        if (__isset.withResourcesAlternateData) {
          field.Name = "withResourcesAlternateData";
          field.Type = TType.Bool;
          field.ID = 6;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithResourcesAlternateData);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteVersion_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NoteGuid: ");
        sb.Append(NoteGuid);
        sb.Append(",UpdateSequenceNum: ");
        sb.Append(UpdateSequenceNum);
        sb.Append(",WithResourcesData: ");
        sb.Append(WithResourcesData);
        sb.Append(",WithResourcesRecognition: ");
        sb.Append(WithResourcesRecognition);
        sb.Append(",WithResourcesAlternateData: ");
        sb.Append(WithResourcesAlternateData);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getNoteVersion_result : TBase
    {
      private Evernote.EDAM.Type.Note _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Note Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getNoteVersion_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Note();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getNoteVersion_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getNoteVersion_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResource_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private bool _withData;
      private bool _withRecognition;
      private bool _withAttributes;
      private bool _withAlternateData;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public bool WithData
      {
        get
        {
          return _withData;
        }
        set
        {
          __isset.withData = true;
          this._withData = value;
        }
      }

      public bool WithRecognition
      {
        get
        {
          return _withRecognition;
        }
        set
        {
          __isset.withRecognition = true;
          this._withRecognition = value;
        }
      }

      public bool WithAttributes
      {
        get
        {
          return _withAttributes;
        }
        set
        {
          __isset.withAttributes = true;
          this._withAttributes = value;
        }
      }

      public bool WithAlternateData
      {
        get
        {
          return _withAlternateData;
        }
        set
        {
          __isset.withAlternateData = true;
          this._withAlternateData = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool withData;
        public bool withRecognition;
        public bool withAttributes;
        public bool withAlternateData;
      }

      public getResource_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Bool) {
                WithData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                WithRecognition = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Bool) {
                WithAttributes = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 6:
              if (field.Type == TType.Bool) {
                WithAlternateData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResource_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (__isset.withData) {
          field.Name = "withData";
          field.Type = TType.Bool;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithData);
          oprot.WriteFieldEnd();
        }
        if (__isset.withRecognition) {
          field.Name = "withRecognition";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithRecognition);
          oprot.WriteFieldEnd();
        }
        if (__isset.withAttributes) {
          field.Name = "withAttributes";
          field.Type = TType.Bool;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithAttributes);
          oprot.WriteFieldEnd();
        }
        if (__isset.withAlternateData) {
          field.Name = "withAlternateData";
          field.Type = TType.Bool;
          field.ID = 6;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithAlternateData);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResource_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",WithData: ");
        sb.Append(WithData);
        sb.Append(",WithRecognition: ");
        sb.Append(WithRecognition);
        sb.Append(",WithAttributes: ");
        sb.Append(WithAttributes);
        sb.Append(",WithAlternateData: ");
        sb.Append(WithAlternateData);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResource_result : TBase
    {
      private Evernote.EDAM.Type.Resource _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Resource Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResource_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Resource();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResource_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResource_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceApplicationData_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceApplicationData_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceApplicationData_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceApplicationData_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceApplicationData_result : TBase
    {
      private Evernote.EDAM.Type.LazyMap _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.LazyMap Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceApplicationData_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.LazyMap();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceApplicationData_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceApplicationData_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
      }

      public getResourceApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceApplicationDataEntry_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setResourceApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;
      private string _value;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }

      public string Value
      {
        get
        {
          return _value;
        }
        set
        {
          __isset.value = true;
          this._value = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
        public bool value;
      }

      public setResourceApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.String) {
                Value = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setResourceApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        if (Value != null && __isset.value) {
          field.Name = "value";
          field.Type = TType.String;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Value);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setResourceApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(",Value: ");
        sb.Append(Value);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setResourceApplicationDataEntry_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public setResourceApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setResourceApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setResourceApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class unsetResourceApplicationDataEntry_args : TBase
    {
      private string _authenticationToken;
      private string _guid;
      private string _key;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string Key
      {
        get
        {
          return _key;
        }
        set
        {
          __isset.key = true;
          this._key = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
        public bool key;
      }

      public unsetResourceApplicationDataEntry_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                Key = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("unsetResourceApplicationDataEntry_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (Key != null && __isset.key) {
          field.Name = "key";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Key);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("unsetResourceApplicationDataEntry_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(",Key: ");
        sb.Append(Key);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class unsetResourceApplicationDataEntry_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public unsetResourceApplicationDataEntry_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("unsetResourceApplicationDataEntry_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("unsetResourceApplicationDataEntry_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateResource_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.Resource _resource;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.Resource Resource
      {
        get
        {
          return _resource;
        }
        set
        {
          __isset.resource = true;
          this._resource = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool resource;
      }

      public updateResource_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Resource = new Evernote.EDAM.Type.Resource();
                Resource.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateResource_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Resource != null && __isset.resource) {
          field.Name = "resource";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Resource.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateResource_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Resource: ");
        sb.Append(Resource== null ? "<null>" : Resource.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateResource_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public updateResource_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateResource_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateResource_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceData_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceData_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceData_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceData_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceData_result : TBase
    {
      private byte[] _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public byte[] Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceData_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadBinary();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceData_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteBinary(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceData_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceByHash_args : TBase
    {
      private string _authenticationToken;
      private string _noteGuid;
      private byte[] _contentHash;
      private bool _withData;
      private bool _withRecognition;
      private bool _withAlternateData;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NoteGuid
      {
        get
        {
          return _noteGuid;
        }
        set
        {
          __isset.noteGuid = true;
          this._noteGuid = value;
        }
      }

      public byte[] ContentHash
      {
        get
        {
          return _contentHash;
        }
        set
        {
          __isset.contentHash = true;
          this._contentHash = value;
        }
      }

      public bool WithData
      {
        get
        {
          return _withData;
        }
        set
        {
          __isset.withData = true;
          this._withData = value;
        }
      }

      public bool WithRecognition
      {
        get
        {
          return _withRecognition;
        }
        set
        {
          __isset.withRecognition = true;
          this._withRecognition = value;
        }
      }

      public bool WithAlternateData
      {
        get
        {
          return _withAlternateData;
        }
        set
        {
          __isset.withAlternateData = true;
          this._withAlternateData = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool noteGuid;
        public bool contentHash;
        public bool withData;
        public bool withRecognition;
        public bool withAlternateData;
      }

      public getResourceByHash_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NoteGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                ContentHash = iprot.ReadBinary();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.Bool) {
                WithData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 5:
              if (field.Type == TType.Bool) {
                WithRecognition = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 6:
              if (field.Type == TType.Bool) {
                WithAlternateData = iprot.ReadBool();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceByHash_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NoteGuid != null && __isset.noteGuid) {
          field.Name = "noteGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NoteGuid);
          oprot.WriteFieldEnd();
        }
        if (ContentHash != null && __isset.contentHash) {
          field.Name = "contentHash";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteBinary(ContentHash);
          oprot.WriteFieldEnd();
        }
        if (__isset.withData) {
          field.Name = "withData";
          field.Type = TType.Bool;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithData);
          oprot.WriteFieldEnd();
        }
        if (__isset.withRecognition) {
          field.Name = "withRecognition";
          field.Type = TType.Bool;
          field.ID = 5;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithRecognition);
          oprot.WriteFieldEnd();
        }
        if (__isset.withAlternateData) {
          field.Name = "withAlternateData";
          field.Type = TType.Bool;
          field.ID = 6;
          oprot.WriteFieldBegin(field);
          oprot.WriteBool(WithAlternateData);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceByHash_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NoteGuid: ");
        sb.Append(NoteGuid);
        sb.Append(",ContentHash: ");
        sb.Append(ContentHash);
        sb.Append(",WithData: ");
        sb.Append(WithData);
        sb.Append(",WithRecognition: ");
        sb.Append(WithRecognition);
        sb.Append(",WithAlternateData: ");
        sb.Append(WithAlternateData);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceByHash_result : TBase
    {
      private Evernote.EDAM.Type.Resource _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Resource Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceByHash_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Resource();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceByHash_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceByHash_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceRecognition_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceRecognition_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceRecognition_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceRecognition_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceRecognition_result : TBase
    {
      private byte[] _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public byte[] Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceRecognition_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadBinary();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceRecognition_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteBinary(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceRecognition_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceAlternateData_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceAlternateData_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceAlternateData_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceAlternateData_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceAlternateData_result : TBase
    {
      private byte[] _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public byte[] Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceAlternateData_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadBinary();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceAlternateData_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteBinary(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceAlternateData_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceAttributes_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public getResourceAttributes_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceAttributes_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceAttributes_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getResourceAttributes_result : TBase
    {
      private Evernote.EDAM.Type.ResourceAttributes _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.ResourceAttributes Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public getResourceAttributes_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.ResourceAttributes();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getResourceAttributes_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getResourceAttributes_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getPublicNotebook_args : TBase
    {
      private int _userId;
      private string _publicUri;

      public int UserId
      {
        get
        {
          return _userId;
        }
        set
        {
          __isset.userId = true;
          this._userId = value;
        }
      }

      public string PublicUri
      {
        get
        {
          return _publicUri;
        }
        set
        {
          __isset.publicUri = true;
          this._publicUri = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool userId;
        public bool publicUri;
      }

      public getPublicNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.I32) {
                UserId = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                PublicUri = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getPublicNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (__isset.userId) {
          field.Name = "userId";
          field.Type = TType.I32;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(UserId);
          oprot.WriteFieldEnd();
        }
        if (PublicUri != null && __isset.publicUri) {
          field.Name = "publicUri";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(PublicUri);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getPublicNotebook_args(");
        sb.Append("UserId: ");
        sb.Append(UserId);
        sb.Append(",PublicUri: ");
        sb.Append(PublicUri);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getPublicNotebook_result : TBase
    {
      private Evernote.EDAM.Type.Notebook _success;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public Evernote.EDAM.Type.Notebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool systemException;
        public bool notFoundException;
      }

      public getPublicNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.Notebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getPublicNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getPublicNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createSharedNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.SharedNotebook _sharedNotebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.SharedNotebook SharedNotebook
      {
        get
        {
          return _sharedNotebook;
        }
        set
        {
          __isset.sharedNotebook = true;
          this._sharedNotebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool sharedNotebook;
      }

      public createSharedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SharedNotebook = new Evernote.EDAM.Type.SharedNotebook();
                SharedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createSharedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (SharedNotebook != null && __isset.sharedNotebook) {
          field.Name = "sharedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          SharedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createSharedNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",SharedNotebook: ");
        sb.Append(SharedNotebook== null ? "<null>" : SharedNotebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createSharedNotebook_result : TBase
    {
      private Evernote.EDAM.Type.SharedNotebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.SharedNotebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public createSharedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.SharedNotebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createSharedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createSharedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateSharedNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.SharedNotebook _sharedNotebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.SharedNotebook SharedNotebook
      {
        get
        {
          return _sharedNotebook;
        }
        set
        {
          __isset.sharedNotebook = true;
          this._sharedNotebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool sharedNotebook;
      }

      public updateSharedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SharedNotebook = new Evernote.EDAM.Type.SharedNotebook();
                SharedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateSharedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (SharedNotebook != null && __isset.sharedNotebook) {
          field.Name = "sharedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          SharedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateSharedNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",SharedNotebook: ");
        sb.Append(SharedNotebook== null ? "<null>" : SharedNotebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateSharedNotebook_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public updateSharedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateSharedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateSharedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setSharedNotebookRecipientSettings_args : TBase
    {
      private string _authenticationToken;
      private long _sharedNotebookId;
      private Evernote.EDAM.Type.SharedNotebookRecipientSettings _recipientSettings;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public long SharedNotebookId
      {
        get
        {
          return _sharedNotebookId;
        }
        set
        {
          __isset.sharedNotebookId = true;
          this._sharedNotebookId = value;
        }
      }

      public Evernote.EDAM.Type.SharedNotebookRecipientSettings RecipientSettings
      {
        get
        {
          return _recipientSettings;
        }
        set
        {
          __isset.recipientSettings = true;
          this._recipientSettings = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool sharedNotebookId;
        public bool recipientSettings;
      }

      public setSharedNotebookRecipientSettings_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.I64) {
                SharedNotebookId = iprot.ReadI64();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                RecipientSettings = new Evernote.EDAM.Type.SharedNotebookRecipientSettings();
                RecipientSettings.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setSharedNotebookRecipientSettings_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (__isset.sharedNotebookId) {
          field.Name = "sharedNotebookId";
          field.Type = TType.I64;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteI64(SharedNotebookId);
          oprot.WriteFieldEnd();
        }
        if (RecipientSettings != null && __isset.recipientSettings) {
          field.Name = "recipientSettings";
          field.Type = TType.Struct;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          RecipientSettings.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setSharedNotebookRecipientSettings_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",SharedNotebookId: ");
        sb.Append(SharedNotebookId);
        sb.Append(",RecipientSettings: ");
        sb.Append(RecipientSettings== null ? "<null>" : RecipientSettings.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class setSharedNotebookRecipientSettings_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public setSharedNotebookRecipientSettings_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("setSharedNotebookRecipientSettings_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("setSharedNotebookRecipientSettings_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class sendMessageToSharedNotebookMembers_args : TBase
    {
      private string _authenticationToken;
      private string _notebookGuid;
      private string _messageText;
      private List<string> _recipients;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string NotebookGuid
      {
        get
        {
          return _notebookGuid;
        }
        set
        {
          __isset.notebookGuid = true;
          this._notebookGuid = value;
        }
      }

      public string MessageText
      {
        get
        {
          return _messageText;
        }
        set
        {
          __isset.messageText = true;
          this._messageText = value;
        }
      }

      public List<string> Recipients
      {
        get
        {
          return _recipients;
        }
        set
        {
          __isset.recipients = true;
          this._recipients = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool notebookGuid;
        public bool messageText;
        public bool recipients;
      }

      public sendMessageToSharedNotebookMembers_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NotebookGuid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                MessageText = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 4:
              if (field.Type == TType.List) {
                {
                  Recipients = new List<string>();
                  TList _list138 = iprot.ReadListBegin();
                  for( int _i139 = 0; _i139 < _list138.Count; ++_i139)
                  {
                    string _elem140 = null;
                    _elem140 = iprot.ReadString();
                    Recipients.Add(_elem140);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("sendMessageToSharedNotebookMembers_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (NotebookGuid != null && __isset.notebookGuid) {
          field.Name = "notebookGuid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NotebookGuid);
          oprot.WriteFieldEnd();
        }
        if (MessageText != null && __isset.messageText) {
          field.Name = "messageText";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(MessageText);
          oprot.WriteFieldEnd();
        }
        if (Recipients != null && __isset.recipients) {
          field.Name = "recipients";
          field.Type = TType.List;
          field.ID = 4;
          oprot.WriteFieldBegin(field);
          {
            oprot.WriteListBegin(new TList(TType.String, Recipients.Count));
            foreach (string _iter141 in Recipients)
            {
              oprot.WriteString(_iter141);
              oprot.WriteListEnd();
            }
          }
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("sendMessageToSharedNotebookMembers_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",NotebookGuid: ");
        sb.Append(NotebookGuid);
        sb.Append(",MessageText: ");
        sb.Append(MessageText);
        sb.Append(",Recipients: ");
        sb.Append(Recipients);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class sendMessageToSharedNotebookMembers_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public sendMessageToSharedNotebookMembers_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("sendMessageToSharedNotebookMembers_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("sendMessageToSharedNotebookMembers_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listSharedNotebooks_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public listSharedNotebooks_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listSharedNotebooks_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listSharedNotebooks_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listSharedNotebooks_result : TBase
    {
      private List<Evernote.EDAM.Type.SharedNotebook> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public List<Evernote.EDAM.Type.SharedNotebook> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public listSharedNotebooks_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.SharedNotebook>();
                  TList _list142 = iprot.ReadListBegin();
                  for( int _i143 = 0; _i143 < _list142.Count; ++_i143)
                  {
                    Evernote.EDAM.Type.SharedNotebook _elem144 = new Evernote.EDAM.Type.SharedNotebook();
                    _elem144 = new Evernote.EDAM.Type.SharedNotebook();
                    _elem144.Read(iprot);
                    Success.Add(_elem144);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listSharedNotebooks_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.SharedNotebook _iter145 in Success)
              {
                _iter145.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listSharedNotebooks_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeSharedNotebooks_args : TBase
    {
      private string _authenticationToken;
      private List<long> _sharedNotebookIds;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public List<long> SharedNotebookIds
      {
        get
        {
          return _sharedNotebookIds;
        }
        set
        {
          __isset.sharedNotebookIds = true;
          this._sharedNotebookIds = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool sharedNotebookIds;
      }

      public expungeSharedNotebooks_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.List) {
                {
                  SharedNotebookIds = new List<long>();
                  TList _list146 = iprot.ReadListBegin();
                  for( int _i147 = 0; _i147 < _list146.Count; ++_i147)
                  {
                    long _elem148 = 0;
                    _elem148 = iprot.ReadI64();
                    SharedNotebookIds.Add(_elem148);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeSharedNotebooks_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (SharedNotebookIds != null && __isset.sharedNotebookIds) {
          field.Name = "sharedNotebookIds";
          field.Type = TType.List;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          {
            oprot.WriteListBegin(new TList(TType.I64, SharedNotebookIds.Count));
            foreach (long _iter149 in SharedNotebookIds)
            {
              oprot.WriteI64(_iter149);
              oprot.WriteListEnd();
            }
          }
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeSharedNotebooks_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",SharedNotebookIds: ");
        sb.Append(SharedNotebookIds);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeSharedNotebooks_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public expungeSharedNotebooks_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeSharedNotebooks_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeSharedNotebooks_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createLinkedNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.LinkedNotebook _linkedNotebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.LinkedNotebook LinkedNotebook
      {
        get
        {
          return _linkedNotebook;
        }
        set
        {
          __isset.linkedNotebook = true;
          this._linkedNotebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool linkedNotebook;
      }

      public createLinkedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                LinkedNotebook = new Evernote.EDAM.Type.LinkedNotebook();
                LinkedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createLinkedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (LinkedNotebook != null && __isset.linkedNotebook) {
          field.Name = "linkedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          LinkedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createLinkedNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",LinkedNotebook: ");
        sb.Append(LinkedNotebook== null ? "<null>" : LinkedNotebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class createLinkedNotebook_result : TBase
    {
      private Evernote.EDAM.Type.LinkedNotebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.LinkedNotebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public createLinkedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.LinkedNotebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("createLinkedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("createLinkedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateLinkedNotebook_args : TBase
    {
      private string _authenticationToken;
      private Evernote.EDAM.Type.LinkedNotebook _linkedNotebook;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public Evernote.EDAM.Type.LinkedNotebook LinkedNotebook
      {
        get
        {
          return _linkedNotebook;
        }
        set
        {
          __isset.linkedNotebook = true;
          this._linkedNotebook = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool linkedNotebook;
      }

      public updateLinkedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                LinkedNotebook = new Evernote.EDAM.Type.LinkedNotebook();
                LinkedNotebook.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateLinkedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (LinkedNotebook != null && __isset.linkedNotebook) {
          field.Name = "linkedNotebook";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          LinkedNotebook.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateLinkedNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",LinkedNotebook: ");
        sb.Append(LinkedNotebook== null ? "<null>" : LinkedNotebook.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class updateLinkedNotebook_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public updateLinkedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("updateLinkedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("updateLinkedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listLinkedNotebooks_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public listLinkedNotebooks_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listLinkedNotebooks_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listLinkedNotebooks_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class listLinkedNotebooks_result : TBase
    {
      private List<Evernote.EDAM.Type.LinkedNotebook> _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public List<Evernote.EDAM.Type.LinkedNotebook> Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public listLinkedNotebooks_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.List) {
                {
                  Success = new List<Evernote.EDAM.Type.LinkedNotebook>();
                  TList _list150 = iprot.ReadListBegin();
                  for( int _i151 = 0; _i151 < _list150.Count; ++_i151)
                  {
                    Evernote.EDAM.Type.LinkedNotebook _elem152 = new Evernote.EDAM.Type.LinkedNotebook();
                    _elem152 = new Evernote.EDAM.Type.LinkedNotebook();
                    _elem152.Read(iprot);
                    Success.Add(_elem152);
                  }
                  iprot.ReadListEnd();
                }
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("listLinkedNotebooks_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.List;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            {
              oprot.WriteListBegin(new TList(TType.Struct, Success.Count));
              foreach (Evernote.EDAM.Type.LinkedNotebook _iter153 in Success)
              {
                _iter153.Write(oprot);
                oprot.WriteListEnd();
              }
            }
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("listLinkedNotebooks_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeLinkedNotebook_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public expungeLinkedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeLinkedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeLinkedNotebook_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class expungeLinkedNotebook_result : TBase
    {
      private int _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public int Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public expungeLinkedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.I32) {
                Success = iprot.ReadI32();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("expungeLinkedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          field.Name = "Success";
          field.Type = TType.I32;
          field.ID = 0;
          oprot.WriteFieldBegin(field);
          oprot.WriteI32(Success);
          oprot.WriteFieldEnd();
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("expungeLinkedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class authenticateToSharedNotebook_args : TBase
    {
      private string _shareKey;
      private string _authenticationToken;

      public string ShareKey
      {
        get
        {
          return _shareKey;
        }
        set
        {
          __isset.shareKey = true;
          this._shareKey = value;
        }
      }

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool shareKey;
        public bool authenticationToken;
      }

      public authenticateToSharedNotebook_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                ShareKey = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("authenticateToSharedNotebook_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (ShareKey != null && __isset.shareKey) {
          field.Name = "shareKey";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(ShareKey);
          oprot.WriteFieldEnd();
        }
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("authenticateToSharedNotebook_args(");
        sb.Append("ShareKey: ");
        sb.Append(ShareKey);
        sb.Append(",AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class authenticateToSharedNotebook_result : TBase
    {
      private Evernote.EDAM.UserStore.AuthenticationResult _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.UserStore.AuthenticationResult Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public authenticateToSharedNotebook_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.UserStore.AuthenticationResult();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("authenticateToSharedNotebook_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("authenticateToSharedNotebook_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSharedNotebookByAuth_args : TBase
    {
      private string _authenticationToken;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
      }

      public getSharedNotebookByAuth_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSharedNotebookByAuth_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSharedNotebookByAuth_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class getSharedNotebookByAuth_result : TBase
    {
      private Evernote.EDAM.Type.SharedNotebook _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Type.SharedNotebook Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public getSharedNotebookByAuth_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.Type.SharedNotebook();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("getSharedNotebookByAuth_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("getSharedNotebookByAuth_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class emailNote_args : TBase
    {
      private string _authenticationToken;
      private NoteEmailParameters _parameters;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public NoteEmailParameters Parameters
      {
        get
        {
          return _parameters;
        }
        set
        {
          __isset.parameters = true;
          this._parameters = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool parameters;
      }

      public emailNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Parameters = new NoteEmailParameters();
                Parameters.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("emailNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Parameters != null && __isset.parameters) {
          field.Name = "parameters";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Parameters.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("emailNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Parameters: ");
        sb.Append(Parameters== null ? "<null>" : Parameters.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class emailNote_result : TBase
    {
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public emailNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("emailNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("emailNote_result(");
        sb.Append("UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class shareNote_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public shareNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("shareNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("shareNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class shareNote_result : TBase
    {
      private string _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public string Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public shareNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.String) {
                Success = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("shareNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.String;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            oprot.WriteString(Success);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("shareNote_result(");
        sb.Append("Success: ");
        sb.Append(Success);
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class stopSharingNote_args : TBase
    {
      private string _authenticationToken;
      private string _guid;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool guid;
      }

      public stopSharingNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("stopSharingNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("stopSharingNote_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Guid: ");
        sb.Append(Guid);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class stopSharingNote_result : TBase
    {
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public stopSharingNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("stopSharingNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("stopSharingNote_result(");
        sb.Append("UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class authenticateToSharedNote_args : TBase
    {
      private string _guid;
      private string _noteKey;
      private string _authenticationToken;

      public string Guid
      {
        get
        {
          return _guid;
        }
        set
        {
          __isset.guid = true;
          this._guid = value;
        }
      }

      public string NoteKey
      {
        get
        {
          return _noteKey;
        }
        set
        {
          __isset.noteKey = true;
          this._noteKey = value;
        }
      }

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool guid;
        public bool noteKey;
        public bool authenticationToken;
      }

      public authenticateToSharedNote_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                Guid = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.String) {
                NoteKey = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("authenticateToSharedNote_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (Guid != null && __isset.guid) {
          field.Name = "guid";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(Guid);
          oprot.WriteFieldEnd();
        }
        if (NoteKey != null && __isset.noteKey) {
          field.Name = "noteKey";
          field.Type = TType.String;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(NoteKey);
          oprot.WriteFieldEnd();
        }
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("authenticateToSharedNote_args(");
        sb.Append("Guid: ");
        sb.Append(Guid);
        sb.Append(",NoteKey: ");
        sb.Append(NoteKey);
        sb.Append(",AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class authenticateToSharedNote_result : TBase
    {
      private Evernote.EDAM.UserStore.AuthenticationResult _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;

      public Evernote.EDAM.UserStore.AuthenticationResult Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool notFoundException;
        public bool systemException;
      }

      public authenticateToSharedNote_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new Evernote.EDAM.UserStore.AuthenticationResult();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("authenticateToSharedNote_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("authenticateToSharedNote_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findRelated_args : TBase
    {
      private string _authenticationToken;
      private RelatedQuery _query;
      private RelatedResultSpec _resultSpec;

      public string AuthenticationToken
      {
        get
        {
          return _authenticationToken;
        }
        set
        {
          __isset.authenticationToken = true;
          this._authenticationToken = value;
        }
      }

      public RelatedQuery Query
      {
        get
        {
          return _query;
        }
        set
        {
          __isset.query = true;
          this._query = value;
        }
      }

      public RelatedResultSpec ResultSpec
      {
        get
        {
          return _resultSpec;
        }
        set
        {
          __isset.resultSpec = true;
          this._resultSpec = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool authenticationToken;
        public bool query;
        public bool resultSpec;
      }

      public findRelated_args() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 1:
              if (field.Type == TType.String) {
                AuthenticationToken = iprot.ReadString();
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                Query = new RelatedQuery();
                Query.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                ResultSpec = new RelatedResultSpec();
                ResultSpec.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findRelated_args");
        oprot.WriteStructBegin(struc);
        TField field = new TField();
        if (AuthenticationToken != null && __isset.authenticationToken) {
          field.Name = "authenticationToken";
          field.Type = TType.String;
          field.ID = 1;
          oprot.WriteFieldBegin(field);
          oprot.WriteString(AuthenticationToken);
          oprot.WriteFieldEnd();
        }
        if (Query != null && __isset.query) {
          field.Name = "query";
          field.Type = TType.Struct;
          field.ID = 2;
          oprot.WriteFieldBegin(field);
          Query.Write(oprot);
          oprot.WriteFieldEnd();
        }
        if (ResultSpec != null && __isset.resultSpec) {
          field.Name = "resultSpec";
          field.Type = TType.Struct;
          field.ID = 3;
          oprot.WriteFieldBegin(field);
          ResultSpec.Write(oprot);
          oprot.WriteFieldEnd();
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findRelated_args(");
        sb.Append("AuthenticationToken: ");
        sb.Append(AuthenticationToken);
        sb.Append(",Query: ");
        sb.Append(Query== null ? "<null>" : Query.ToString());
        sb.Append(",ResultSpec: ");
        sb.Append(ResultSpec== null ? "<null>" : ResultSpec.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }


    #if !SILVERLIGHT && !NETFX_CORE
    [Serializable]
    #endif
    public partial class findRelated_result : TBase
    {
      private RelatedResult _success;
      private Evernote.EDAM.Error.EDAMUserException _userException;
      private Evernote.EDAM.Error.EDAMSystemException _systemException;
      private Evernote.EDAM.Error.EDAMNotFoundException _notFoundException;

      public RelatedResult Success
      {
        get
        {
          return _success;
        }
        set
        {
          __isset.success = true;
          this._success = value;
        }
      }

      public Evernote.EDAM.Error.EDAMUserException UserException
      {
        get
        {
          return _userException;
        }
        set
        {
          __isset.userException = true;
          this._userException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMSystemException SystemException
      {
        get
        {
          return _systemException;
        }
        set
        {
          __isset.systemException = true;
          this._systemException = value;
        }
      }

      public Evernote.EDAM.Error.EDAMNotFoundException NotFoundException
      {
        get
        {
          return _notFoundException;
        }
        set
        {
          __isset.notFoundException = true;
          this._notFoundException = value;
        }
      }


      public Isset __isset;
      #if !SILVERLIGHT && !NETFX_CORE
      [Serializable]
      #endif
      public struct Isset {
        public bool success;
        public bool userException;
        public bool systemException;
        public bool notFoundException;
      }

      public findRelated_result() {
      }

      public void Read (TProtocol iprot)
      {
        TField field;
        iprot.ReadStructBegin();
        while (true)
        {
          field = iprot.ReadFieldBegin();
          if (field.Type == TType.Stop) { 
            break;
          }
          switch (field.ID)
          {
            case 0:
              if (field.Type == TType.Struct) {
                Success = new RelatedResult();
                Success.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 1:
              if (field.Type == TType.Struct) {
                UserException = new Evernote.EDAM.Error.EDAMUserException();
                UserException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 2:
              if (field.Type == TType.Struct) {
                SystemException = new Evernote.EDAM.Error.EDAMSystemException();
                SystemException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            case 3:
              if (field.Type == TType.Struct) {
                NotFoundException = new Evernote.EDAM.Error.EDAMNotFoundException();
                NotFoundException.Read(iprot);
              } else { 
                TProtocolUtil.Skip(iprot, field.Type);
              }
              break;
            default: 
              TProtocolUtil.Skip(iprot, field.Type);
              break;
          }
          iprot.ReadFieldEnd();
        }
        iprot.ReadStructEnd();
      }

      public void Write(TProtocol oprot) {
        TStruct struc = new TStruct("findRelated_result");
        oprot.WriteStructBegin(struc);
        TField field = new TField();

        if (this.__isset.success) {
          if (Success != null) {
            field.Name = "Success";
            field.Type = TType.Struct;
            field.ID = 0;
            oprot.WriteFieldBegin(field);
            Success.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.userException) {
          if (UserException != null) {
            field.Name = "UserException";
            field.Type = TType.Struct;
            field.ID = 1;
            oprot.WriteFieldBegin(field);
            UserException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.systemException) {
          if (SystemException != null) {
            field.Name = "SystemException";
            field.Type = TType.Struct;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            SystemException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        } else if (this.__isset.notFoundException) {
          if (NotFoundException != null) {
            field.Name = "NotFoundException";
            field.Type = TType.Struct;
            field.ID = 3;
            oprot.WriteFieldBegin(field);
            NotFoundException.Write(oprot);
            oprot.WriteFieldEnd();
          }
        }
        oprot.WriteFieldStop();
        oprot.WriteStructEnd();
      }

      public override string ToString() {
        StringBuilder sb = new StringBuilder("findRelated_result(");
        sb.Append("Success: ");
        sb.Append(Success== null ? "<null>" : Success.ToString());
        sb.Append(",UserException: ");
        sb.Append(UserException== null ? "<null>" : UserException.ToString());
        sb.Append(",SystemException: ");
        sb.Append(SystemException== null ? "<null>" : SystemException.ToString());
        sb.Append(",NotFoundException: ");
        sb.Append(NotFoundException== null ? "<null>" : NotFoundException.ToString());
        sb.Append(")");
        return sb.ToString();
      }

    }

  }
}
