/src/main/java/com/evernote/edam/notestore/NoteStore.java

/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
package com.evernote.edam.notestore;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;

import com.evernote.thrift.*;
import com.evernote.thrift.protocol.*;

public class NoteStore {

  public interface Iface extends NoteStoreIface { }

  public static class Client implements TServiceClient, 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 getInputProtocol()
    {
      return this.iprot_;
    }

    public TProtocol getOutputProtocol()
    {
      return this.oprot_;
    }

    public SyncState getSyncState(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getSyncState(authenticationToken);
      return recv_getSyncState();
    }

    public void send_getSyncState(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getSyncState", TMessageType.CALL, ++seqid_));
      getSyncState_args args = new getSyncState_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncState recv_getSyncState() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getSyncState failed: out of sequence response");
      }
      getSyncState_result result = new getSyncState_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getSyncState failed: unknown result");
    }

    public SyncState getSyncStateWithMetrics(String authenticationToken, ClientUsageMetrics clientMetrics) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getSyncStateWithMetrics(authenticationToken, clientMetrics);
      return recv_getSyncStateWithMetrics();
    }

    public void send_getSyncStateWithMetrics(String authenticationToken, ClientUsageMetrics clientMetrics) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getSyncStateWithMetrics", TMessageType.CALL, ++seqid_));
      getSyncStateWithMetrics_args args = new getSyncStateWithMetrics_args();
      args.setAuthenticationToken(authenticationToken);
      args.setClientMetrics(clientMetrics);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncState recv_getSyncStateWithMetrics() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getSyncStateWithMetrics failed: out of sequence response");
      }
      getSyncStateWithMetrics_result result = new getSyncStateWithMetrics_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getSyncStateWithMetrics failed: unknown result");
    }

    public SyncChunk getSyncChunk(String authenticationToken, int afterUSN, int maxEntries, boolean fullSyncOnly) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getSyncChunk(authenticationToken, afterUSN, maxEntries, fullSyncOnly);
      return recv_getSyncChunk();
    }

    public void send_getSyncChunk(String authenticationToken, int afterUSN, int maxEntries, boolean fullSyncOnly) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getSyncChunk", TMessageType.CALL, ++seqid_));
      getSyncChunk_args args = new getSyncChunk_args();
      args.setAuthenticationToken(authenticationToken);
      args.setAfterUSN(afterUSN);
      args.setMaxEntries(maxEntries);
      args.setFullSyncOnly(fullSyncOnly);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncChunk recv_getSyncChunk() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getSyncChunk failed: out of sequence response");
      }
      getSyncChunk_result result = new getSyncChunk_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getSyncChunk failed: unknown result");
    }

    public SyncChunk getFilteredSyncChunk(String authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getFilteredSyncChunk(authenticationToken, afterUSN, maxEntries, filter);
      return recv_getFilteredSyncChunk();
    }

    public void send_getFilteredSyncChunk(String authenticationToken, int afterUSN, int maxEntries, SyncChunkFilter filter) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getFilteredSyncChunk", TMessageType.CALL, ++seqid_));
      getFilteredSyncChunk_args args = new getFilteredSyncChunk_args();
      args.setAuthenticationToken(authenticationToken);
      args.setAfterUSN(afterUSN);
      args.setMaxEntries(maxEntries);
      args.setFilter(filter);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncChunk recv_getFilteredSyncChunk() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getFilteredSyncChunk failed: out of sequence response");
      }
      getFilteredSyncChunk_result result = new getFilteredSyncChunk_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getFilteredSyncChunk failed: unknown result");
    }

    public SyncState getLinkedNotebookSyncState(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getLinkedNotebookSyncState(authenticationToken, linkedNotebook);
      return recv_getLinkedNotebookSyncState();
    }

    public void send_getLinkedNotebookSyncState(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getLinkedNotebookSyncState", TMessageType.CALL, ++seqid_));
      getLinkedNotebookSyncState_args args = new getLinkedNotebookSyncState_args();
      args.setAuthenticationToken(authenticationToken);
      args.setLinkedNotebook(linkedNotebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncState recv_getLinkedNotebookSyncState() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getLinkedNotebookSyncState failed: out of sequence response");
      }
      getLinkedNotebookSyncState_result result = new getLinkedNotebookSyncState_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getLinkedNotebookSyncState failed: unknown result");
    }

    public SyncChunk getLinkedNotebookSyncChunk(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, boolean fullSyncOnly) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getLinkedNotebookSyncChunk(authenticationToken, linkedNotebook, afterUSN, maxEntries, fullSyncOnly);
      return recv_getLinkedNotebookSyncChunk();
    }

    public void send_getLinkedNotebookSyncChunk(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook, int afterUSN, int maxEntries, boolean fullSyncOnly) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getLinkedNotebookSyncChunk", TMessageType.CALL, ++seqid_));
      getLinkedNotebookSyncChunk_args args = new getLinkedNotebookSyncChunk_args();
      args.setAuthenticationToken(authenticationToken);
      args.setLinkedNotebook(linkedNotebook);
      args.setAfterUSN(afterUSN);
      args.setMaxEntries(maxEntries);
      args.setFullSyncOnly(fullSyncOnly);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public SyncChunk recv_getLinkedNotebookSyncChunk() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getLinkedNotebookSyncChunk failed: out of sequence response");
      }
      getLinkedNotebookSyncChunk_result result = new getLinkedNotebookSyncChunk_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getLinkedNotebookSyncChunk failed: unknown result");
    }

    public List<com.evernote.edam.type.Notebook> listNotebooks(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_listNotebooks(authenticationToken);
      return recv_listNotebooks();
    }

    public void send_listNotebooks(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listNotebooks", TMessageType.CALL, ++seqid_));
      listNotebooks_args args = new listNotebooks_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.Notebook> recv_listNotebooks() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listNotebooks failed: out of sequence response");
      }
      listNotebooks_result result = new listNotebooks_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listNotebooks failed: unknown result");
    }

    public com.evernote.edam.type.Notebook getNotebook(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNotebook(authenticationToken, guid);
      return recv_getNotebook();
    }

    public void send_getNotebook(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNotebook", TMessageType.CALL, ++seqid_));
      getNotebook_args args = new getNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Notebook recv_getNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNotebook failed: out of sequence response");
      }
      getNotebook_result result = new getNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNotebook failed: unknown result");
    }

    public com.evernote.edam.type.Notebook getDefaultNotebook(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getDefaultNotebook(authenticationToken);
      return recv_getDefaultNotebook();
    }

    public void send_getDefaultNotebook(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getDefaultNotebook", TMessageType.CALL, ++seqid_));
      getDefaultNotebook_args args = new getDefaultNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Notebook recv_getDefaultNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getDefaultNotebook failed: out of sequence response");
      }
      getDefaultNotebook_result result = new getDefaultNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultNotebook failed: unknown result");
    }

    public com.evernote.edam.type.Notebook createNotebook(String authenticationToken, com.evernote.edam.type.Notebook notebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_createNotebook(authenticationToken, notebook);
      return recv_createNotebook();
    }

    public void send_createNotebook(String authenticationToken, com.evernote.edam.type.Notebook notebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createNotebook", TMessageType.CALL, ++seqid_));
      createNotebook_args args = new createNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNotebook(notebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Notebook recv_createNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createNotebook failed: out of sequence response");
      }
      createNotebook_result result = new createNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createNotebook failed: unknown result");
    }

    public int updateNotebook(String authenticationToken, com.evernote.edam.type.Notebook notebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_updateNotebook(authenticationToken, notebook);
      return recv_updateNotebook();
    }

    public void send_updateNotebook(String authenticationToken, com.evernote.edam.type.Notebook notebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateNotebook", TMessageType.CALL, ++seqid_));
      updateNotebook_args args = new updateNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNotebook(notebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateNotebook failed: out of sequence response");
      }
      updateNotebook_result result = new updateNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateNotebook failed: unknown result");
    }

    public int expungeNotebook(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_expungeNotebook(authenticationToken, guid);
      return recv_expungeNotebook();
    }

    public void send_expungeNotebook(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeNotebook", TMessageType.CALL, ++seqid_));
      expungeNotebook_args args = new expungeNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeNotebook failed: out of sequence response");
      }
      expungeNotebook_result result = new expungeNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeNotebook failed: unknown result");
    }

    public List<com.evernote.edam.type.Tag> listTags(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_listTags(authenticationToken);
      return recv_listTags();
    }

    public void send_listTags(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listTags", TMessageType.CALL, ++seqid_));
      listTags_args args = new listTags_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.Tag> recv_listTags() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listTags failed: out of sequence response");
      }
      listTags_result result = new listTags_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listTags failed: unknown result");
    }

    public List<com.evernote.edam.type.Tag> listTagsByNotebook(String authenticationToken, String notebookGuid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_listTagsByNotebook(authenticationToken, notebookGuid);
      return recv_listTagsByNotebook();
    }

    public void send_listTagsByNotebook(String authenticationToken, String notebookGuid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listTagsByNotebook", TMessageType.CALL, ++seqid_));
      listTagsByNotebook_args args = new listTagsByNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNotebookGuid(notebookGuid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.Tag> recv_listTagsByNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listTagsByNotebook failed: out of sequence response");
      }
      listTagsByNotebook_result result = new listTagsByNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listTagsByNotebook failed: unknown result");
    }

    public com.evernote.edam.type.Tag getTag(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getTag(authenticationToken, guid);
      return recv_getTag();
    }

    public void send_getTag(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getTag", TMessageType.CALL, ++seqid_));
      getTag_args args = new getTag_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Tag recv_getTag() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getTag failed: out of sequence response");
      }
      getTag_result result = new getTag_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getTag failed: unknown result");
    }

    public com.evernote.edam.type.Tag createTag(String authenticationToken, com.evernote.edam.type.Tag tag) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_createTag(authenticationToken, tag);
      return recv_createTag();
    }

    public void send_createTag(String authenticationToken, com.evernote.edam.type.Tag tag) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createTag", TMessageType.CALL, ++seqid_));
      createTag_args args = new createTag_args();
      args.setAuthenticationToken(authenticationToken);
      args.setTag(tag);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Tag recv_createTag() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createTag failed: out of sequence response");
      }
      createTag_result result = new createTag_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createTag failed: unknown result");
    }

    public int updateTag(String authenticationToken, com.evernote.edam.type.Tag tag) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_updateTag(authenticationToken, tag);
      return recv_updateTag();
    }

    public void send_updateTag(String authenticationToken, com.evernote.edam.type.Tag tag) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateTag", TMessageType.CALL, ++seqid_));
      updateTag_args args = new updateTag_args();
      args.setAuthenticationToken(authenticationToken);
      args.setTag(tag);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateTag() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateTag failed: out of sequence response");
      }
      updateTag_result result = new updateTag_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateTag failed: unknown result");
    }

    public void untagAll(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_untagAll(authenticationToken, guid);
      recv_untagAll();
    }

    public void send_untagAll(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("untagAll", TMessageType.CALL, ++seqid_));
      untagAll_args args = new untagAll_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public void recv_untagAll() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "untagAll failed: out of sequence response");
      }
      untagAll_result result = new untagAll_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      return;
    }

    public int expungeTag(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_expungeTag(authenticationToken, guid);
      return recv_expungeTag();
    }

    public void send_expungeTag(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeTag", TMessageType.CALL, ++seqid_));
      expungeTag_args args = new expungeTag_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeTag() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeTag failed: out of sequence response");
      }
      expungeTag_result result = new expungeTag_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeTag failed: unknown result");
    }

    public List<com.evernote.edam.type.SavedSearch> listSearches(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_listSearches(authenticationToken);
      return recv_listSearches();
    }

    public void send_listSearches(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listSearches", TMessageType.CALL, ++seqid_));
      listSearches_args args = new listSearches_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.SavedSearch> recv_listSearches() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listSearches failed: out of sequence response");
      }
      listSearches_result result = new listSearches_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listSearches failed: unknown result");
    }

    public com.evernote.edam.type.SavedSearch getSearch(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getSearch(authenticationToken, guid);
      return recv_getSearch();
    }

    public void send_getSearch(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getSearch", TMessageType.CALL, ++seqid_));
      getSearch_args args = new getSearch_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.SavedSearch recv_getSearch() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getSearch failed: out of sequence response");
      }
      getSearch_result result = new getSearch_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getSearch failed: unknown result");
    }

    public com.evernote.edam.type.SavedSearch createSearch(String authenticationToken, com.evernote.edam.type.SavedSearch search) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_createSearch(authenticationToken, search);
      return recv_createSearch();
    }

    public void send_createSearch(String authenticationToken, com.evernote.edam.type.SavedSearch search) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createSearch", TMessageType.CALL, ++seqid_));
      createSearch_args args = new createSearch_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSearch(search);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.SavedSearch recv_createSearch() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createSearch failed: out of sequence response");
      }
      createSearch_result result = new createSearch_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createSearch failed: unknown result");
    }

    public int updateSearch(String authenticationToken, com.evernote.edam.type.SavedSearch search) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_updateSearch(authenticationToken, search);
      return recv_updateSearch();
    }

    public void send_updateSearch(String authenticationToken, com.evernote.edam.type.SavedSearch search) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateSearch", TMessageType.CALL, ++seqid_));
      updateSearch_args args = new updateSearch_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSearch(search);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateSearch() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateSearch failed: out of sequence response");
      }
      updateSearch_result result = new updateSearch_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateSearch failed: unknown result");
    }

    public int expungeSearch(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_expungeSearch(authenticationToken, guid);
      return recv_expungeSearch();
    }

    public void send_expungeSearch(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeSearch", TMessageType.CALL, ++seqid_));
      expungeSearch_args args = new expungeSearch_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeSearch() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeSearch failed: out of sequence response");
      }
      expungeSearch_result result = new expungeSearch_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeSearch failed: unknown result");
    }

    public NoteList findNotes(String authenticationToken, NoteFilter filter, int offset, int maxNotes) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_findNotes(authenticationToken, filter, offset, maxNotes);
      return recv_findNotes();
    }

    public void send_findNotes(String authenticationToken, NoteFilter filter, int offset, int maxNotes) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("findNotes", TMessageType.CALL, ++seqid_));
      findNotes_args args = new findNotes_args();
      args.setAuthenticationToken(authenticationToken);
      args.setFilter(filter);
      args.setOffset(offset);
      args.setMaxNotes(maxNotes);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public NoteList recv_findNotes() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "findNotes failed: out of sequence response");
      }
      findNotes_result result = new findNotes_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "findNotes failed: unknown result");
    }

    public int findNoteOffset(String authenticationToken, NoteFilter filter, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_findNoteOffset(authenticationToken, filter, guid);
      return recv_findNoteOffset();
    }

    public void send_findNoteOffset(String authenticationToken, NoteFilter filter, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("findNoteOffset", TMessageType.CALL, ++seqid_));
      findNoteOffset_args args = new findNoteOffset_args();
      args.setAuthenticationToken(authenticationToken);
      args.setFilter(filter);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_findNoteOffset() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "findNoteOffset failed: out of sequence response");
      }
      findNoteOffset_result result = new findNoteOffset_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "findNoteOffset failed: unknown result");
    }

    public NotesMetadataList findNotesMetadata(String authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_findNotesMetadata(authenticationToken, filter, offset, maxNotes, resultSpec);
      return recv_findNotesMetadata();
    }

    public void send_findNotesMetadata(String authenticationToken, NoteFilter filter, int offset, int maxNotes, NotesMetadataResultSpec resultSpec) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("findNotesMetadata", TMessageType.CALL, ++seqid_));
      findNotesMetadata_args args = new findNotesMetadata_args();
      args.setAuthenticationToken(authenticationToken);
      args.setFilter(filter);
      args.setOffset(offset);
      args.setMaxNotes(maxNotes);
      args.setResultSpec(resultSpec);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public NotesMetadataList recv_findNotesMetadata() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "findNotesMetadata failed: out of sequence response");
      }
      findNotesMetadata_result result = new findNotesMetadata_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "findNotesMetadata failed: unknown result");
    }

    public NoteCollectionCounts findNoteCounts(String authenticationToken, NoteFilter filter, boolean withTrash) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_findNoteCounts(authenticationToken, filter, withTrash);
      return recv_findNoteCounts();
    }

    public void send_findNoteCounts(String authenticationToken, NoteFilter filter, boolean withTrash) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("findNoteCounts", TMessageType.CALL, ++seqid_));
      findNoteCounts_args args = new findNoteCounts_args();
      args.setAuthenticationToken(authenticationToken);
      args.setFilter(filter);
      args.setWithTrash(withTrash);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public NoteCollectionCounts recv_findNoteCounts() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "findNoteCounts failed: out of sequence response");
      }
      findNoteCounts_result result = new findNoteCounts_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "findNoteCounts failed: unknown result");
    }

    public com.evernote.edam.type.Note getNote(String authenticationToken, String guid, boolean withContent, boolean withResourcesData, boolean withResourcesRecognition, boolean withResourcesAlternateData) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNote(authenticationToken, guid, withContent, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
      return recv_getNote();
    }

    public void send_getNote(String authenticationToken, String guid, boolean withContent, boolean withResourcesData, boolean withResourcesRecognition, boolean withResourcesAlternateData) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNote", TMessageType.CALL, ++seqid_));
      getNote_args args = new getNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setWithContent(withContent);
      args.setWithResourcesData(withResourcesData);
      args.setWithResourcesRecognition(withResourcesRecognition);
      args.setWithResourcesAlternateData(withResourcesAlternateData);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Note recv_getNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNote failed: out of sequence response");
      }
      getNote_result result = new getNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNote failed: unknown result");
    }

    public com.evernote.edam.type.LazyMap getNoteApplicationData(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteApplicationData(authenticationToken, guid);
      return recv_getNoteApplicationData();
    }

    public void send_getNoteApplicationData(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteApplicationData", TMessageType.CALL, ++seqid_));
      getNoteApplicationData_args args = new getNoteApplicationData_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.LazyMap recv_getNoteApplicationData() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteApplicationData failed: out of sequence response");
      }
      getNoteApplicationData_result result = new getNoteApplicationData_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteApplicationData failed: unknown result");
    }

    public String getNoteApplicationDataEntry(String authenticationToken, String guid, String key) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteApplicationDataEntry(authenticationToken, guid, key);
      return recv_getNoteApplicationDataEntry();
    }

    public void send_getNoteApplicationDataEntry(String authenticationToken, String guid, String key) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteApplicationDataEntry", TMessageType.CALL, ++seqid_));
      getNoteApplicationDataEntry_args args = new getNoteApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_getNoteApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteApplicationDataEntry failed: out of sequence response");
      }
      getNoteApplicationDataEntry_result result = new getNoteApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteApplicationDataEntry failed: unknown result");
    }

    public int setNoteApplicationDataEntry(String authenticationToken, String guid, String key, String value) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_setNoteApplicationDataEntry(authenticationToken, guid, key, value);
      return recv_setNoteApplicationDataEntry();
    }

    public void send_setNoteApplicationDataEntry(String authenticationToken, String guid, String key, String value) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("setNoteApplicationDataEntry", TMessageType.CALL, ++seqid_));
      setNoteApplicationDataEntry_args args = new setNoteApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.setValue(value);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_setNoteApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "setNoteApplicationDataEntry failed: out of sequence response");
      }
      setNoteApplicationDataEntry_result result = new setNoteApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "setNoteApplicationDataEntry failed: unknown result");
    }

    public int unsetNoteApplicationDataEntry(String authenticationToken, String guid, String key) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_unsetNoteApplicationDataEntry(authenticationToken, guid, key);
      return recv_unsetNoteApplicationDataEntry();
    }

    public void send_unsetNoteApplicationDataEntry(String authenticationToken, String guid, String key) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("unsetNoteApplicationDataEntry", TMessageType.CALL, ++seqid_));
      unsetNoteApplicationDataEntry_args args = new unsetNoteApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_unsetNoteApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "unsetNoteApplicationDataEntry failed: out of sequence response");
      }
      unsetNoteApplicationDataEntry_result result = new unsetNoteApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "unsetNoteApplicationDataEntry failed: unknown result");
    }

    public String getNoteContent(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteContent(authenticationToken, guid);
      return recv_getNoteContent();
    }

    public void send_getNoteContent(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteContent", TMessageType.CALL, ++seqid_));
      getNoteContent_args args = new getNoteContent_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_getNoteContent() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteContent failed: out of sequence response");
      }
      getNoteContent_result result = new getNoteContent_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteContent failed: unknown result");
    }

    public String getNoteSearchText(String authenticationToken, String guid, boolean noteOnly, boolean tokenizeForIndexing) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteSearchText(authenticationToken, guid, noteOnly, tokenizeForIndexing);
      return recv_getNoteSearchText();
    }

    public void send_getNoteSearchText(String authenticationToken, String guid, boolean noteOnly, boolean tokenizeForIndexing) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteSearchText", TMessageType.CALL, ++seqid_));
      getNoteSearchText_args args = new getNoteSearchText_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setNoteOnly(noteOnly);
      args.setTokenizeForIndexing(tokenizeForIndexing);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_getNoteSearchText() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteSearchText failed: out of sequence response");
      }
      getNoteSearchText_result result = new getNoteSearchText_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteSearchText failed: unknown result");
    }

    public String getResourceSearchText(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceSearchText(authenticationToken, guid);
      return recv_getResourceSearchText();
    }

    public void send_getResourceSearchText(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceSearchText", TMessageType.CALL, ++seqid_));
      getResourceSearchText_args args = new getResourceSearchText_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_getResourceSearchText() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceSearchText failed: out of sequence response");
      }
      getResourceSearchText_result result = new getResourceSearchText_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceSearchText failed: unknown result");
    }

    public List<String> getNoteTagNames(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteTagNames(authenticationToken, guid);
      return recv_getNoteTagNames();
    }

    public void send_getNoteTagNames(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteTagNames", TMessageType.CALL, ++seqid_));
      getNoteTagNames_args args = new getNoteTagNames_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<String> recv_getNoteTagNames() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteTagNames failed: out of sequence response");
      }
      getNoteTagNames_result result = new getNoteTagNames_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteTagNames failed: unknown result");
    }

    public com.evernote.edam.type.Note createNote(String authenticationToken, com.evernote.edam.type.Note note) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_createNote(authenticationToken, note);
      return recv_createNote();
    }

    public void send_createNote(String authenticationToken, com.evernote.edam.type.Note note) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createNote", TMessageType.CALL, ++seqid_));
      createNote_args args = new createNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNote(note);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Note recv_createNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createNote failed: out of sequence response");
      }
      createNote_result result = new createNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createNote failed: unknown result");
    }

    public com.evernote.edam.type.Note updateNote(String authenticationToken, com.evernote.edam.type.Note note) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_updateNote(authenticationToken, note);
      return recv_updateNote();
    }

    public void send_updateNote(String authenticationToken, com.evernote.edam.type.Note note) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateNote", TMessageType.CALL, ++seqid_));
      updateNote_args args = new updateNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNote(note);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Note recv_updateNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateNote failed: out of sequence response");
      }
      updateNote_result result = new updateNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateNote failed: unknown result");
    }

    public int deleteNote(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_deleteNote(authenticationToken, guid);
      return recv_deleteNote();
    }

    public void send_deleteNote(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("deleteNote", TMessageType.CALL, ++seqid_));
      deleteNote_args args = new deleteNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_deleteNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "deleteNote failed: out of sequence response");
      }
      deleteNote_result result = new deleteNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "deleteNote failed: unknown result");
    }

    public int expungeNote(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_expungeNote(authenticationToken, guid);
      return recv_expungeNote();
    }

    public void send_expungeNote(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeNote", TMessageType.CALL, ++seqid_));
      expungeNote_args args = new expungeNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeNote failed: out of sequence response");
      }
      expungeNote_result result = new expungeNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeNote failed: unknown result");
    }

    public int expungeNotes(String authenticationToken, List<String> noteGuids) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_expungeNotes(authenticationToken, noteGuids);
      return recv_expungeNotes();
    }

    public void send_expungeNotes(String authenticationToken, List<String> noteGuids) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeNotes", TMessageType.CALL, ++seqid_));
      expungeNotes_args args = new expungeNotes_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNoteGuids(noteGuids);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeNotes() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeNotes failed: out of sequence response");
      }
      expungeNotes_result result = new expungeNotes_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeNotes failed: unknown result");
    }

    public int expungeInactiveNotes(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_expungeInactiveNotes(authenticationToken);
      return recv_expungeInactiveNotes();
    }

    public void send_expungeInactiveNotes(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeInactiveNotes", TMessageType.CALL, ++seqid_));
      expungeInactiveNotes_args args = new expungeInactiveNotes_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeInactiveNotes() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeInactiveNotes failed: out of sequence response");
      }
      expungeInactiveNotes_result result = new expungeInactiveNotes_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeInactiveNotes failed: unknown result");
    }

    public com.evernote.edam.type.Note copyNote(String authenticationToken, String noteGuid, String toNotebookGuid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_copyNote(authenticationToken, noteGuid, toNotebookGuid);
      return recv_copyNote();
    }

    public void send_copyNote(String authenticationToken, String noteGuid, String toNotebookGuid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("copyNote", TMessageType.CALL, ++seqid_));
      copyNote_args args = new copyNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNoteGuid(noteGuid);
      args.setToNotebookGuid(toNotebookGuid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Note recv_copyNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "copyNote failed: out of sequence response");
      }
      copyNote_result result = new copyNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "copyNote failed: unknown result");
    }

    public List<NoteVersionId> listNoteVersions(String authenticationToken, String noteGuid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_listNoteVersions(authenticationToken, noteGuid);
      return recv_listNoteVersions();
    }

    public void send_listNoteVersions(String authenticationToken, String noteGuid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listNoteVersions", TMessageType.CALL, ++seqid_));
      listNoteVersions_args args = new listNoteVersions_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNoteGuid(noteGuid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<NoteVersionId> recv_listNoteVersions() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listNoteVersions failed: out of sequence response");
      }
      listNoteVersions_result result = new listNoteVersions_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listNoteVersions failed: unknown result");
    }

    public com.evernote.edam.type.Note getNoteVersion(String authenticationToken, String noteGuid, int updateSequenceNum, boolean withResourcesData, boolean withResourcesRecognition, boolean withResourcesAlternateData) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getNoteVersion(authenticationToken, noteGuid, updateSequenceNum, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
      return recv_getNoteVersion();
    }

    public void send_getNoteVersion(String authenticationToken, String noteGuid, int updateSequenceNum, boolean withResourcesData, boolean withResourcesRecognition, boolean withResourcesAlternateData) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getNoteVersion", TMessageType.CALL, ++seqid_));
      getNoteVersion_args args = new getNoteVersion_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNoteGuid(noteGuid);
      args.setUpdateSequenceNum(updateSequenceNum);
      args.setWithResourcesData(withResourcesData);
      args.setWithResourcesRecognition(withResourcesRecognition);
      args.setWithResourcesAlternateData(withResourcesAlternateData);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Note recv_getNoteVersion() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getNoteVersion failed: out of sequence response");
      }
      getNoteVersion_result result = new getNoteVersion_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoteVersion failed: unknown result");
    }

    public com.evernote.edam.type.Resource getResource(String authenticationToken, String guid, boolean withData, boolean withRecognition, boolean withAttributes, boolean withAlternateData) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResource(authenticationToken, guid, withData, withRecognition, withAttributes, withAlternateData);
      return recv_getResource();
    }

    public void send_getResource(String authenticationToken, String guid, boolean withData, boolean withRecognition, boolean withAttributes, boolean withAlternateData) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResource", TMessageType.CALL, ++seqid_));
      getResource_args args = new getResource_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setWithData(withData);
      args.setWithRecognition(withRecognition);
      args.setWithAttributes(withAttributes);
      args.setWithAlternateData(withAlternateData);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Resource recv_getResource() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResource failed: out of sequence response");
      }
      getResource_result result = new getResource_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResource failed: unknown result");
    }

    public com.evernote.edam.type.LazyMap getResourceApplicationData(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceApplicationData(authenticationToken, guid);
      return recv_getResourceApplicationData();
    }

    public void send_getResourceApplicationData(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceApplicationData", TMessageType.CALL, ++seqid_));
      getResourceApplicationData_args args = new getResourceApplicationData_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.LazyMap recv_getResourceApplicationData() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceApplicationData failed: out of sequence response");
      }
      getResourceApplicationData_result result = new getResourceApplicationData_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceApplicationData failed: unknown result");
    }

    public String getResourceApplicationDataEntry(String authenticationToken, String guid, String key) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceApplicationDataEntry(authenticationToken, guid, key);
      return recv_getResourceApplicationDataEntry();
    }

    public void send_getResourceApplicationDataEntry(String authenticationToken, String guid, String key) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceApplicationDataEntry", TMessageType.CALL, ++seqid_));
      getResourceApplicationDataEntry_args args = new getResourceApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_getResourceApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceApplicationDataEntry failed: out of sequence response");
      }
      getResourceApplicationDataEntry_result result = new getResourceApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceApplicationDataEntry failed: unknown result");
    }

    public int setResourceApplicationDataEntry(String authenticationToken, String guid, String key, String value) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_setResourceApplicationDataEntry(authenticationToken, guid, key, value);
      return recv_setResourceApplicationDataEntry();
    }

    public void send_setResourceApplicationDataEntry(String authenticationToken, String guid, String key, String value) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("setResourceApplicationDataEntry", TMessageType.CALL, ++seqid_));
      setResourceApplicationDataEntry_args args = new setResourceApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.setValue(value);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_setResourceApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "setResourceApplicationDataEntry failed: out of sequence response");
      }
      setResourceApplicationDataEntry_result result = new setResourceApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "setResourceApplicationDataEntry failed: unknown result");
    }

    public int unsetResourceApplicationDataEntry(String authenticationToken, String guid, String key) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_unsetResourceApplicationDataEntry(authenticationToken, guid, key);
      return recv_unsetResourceApplicationDataEntry();
    }

    public void send_unsetResourceApplicationDataEntry(String authenticationToken, String guid, String key) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("unsetResourceApplicationDataEntry", TMessageType.CALL, ++seqid_));
      unsetResourceApplicationDataEntry_args args = new unsetResourceApplicationDataEntry_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.setKey(key);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_unsetResourceApplicationDataEntry() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "unsetResourceApplicationDataEntry failed: out of sequence response");
      }
      unsetResourceApplicationDataEntry_result result = new unsetResourceApplicationDataEntry_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "unsetResourceApplicationDataEntry failed: unknown result");
    }

    public int updateResource(String authenticationToken, com.evernote.edam.type.Resource resource) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_updateResource(authenticationToken, resource);
      return recv_updateResource();
    }

    public void send_updateResource(String authenticationToken, com.evernote.edam.type.Resource resource) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateResource", TMessageType.CALL, ++seqid_));
      updateResource_args args = new updateResource_args();
      args.setAuthenticationToken(authenticationToken);
      args.setResource(resource);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateResource() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateResource failed: out of sequence response");
      }
      updateResource_result result = new updateResource_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateResource failed: unknown result");
    }

    public byte[] getResourceData(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceData(authenticationToken, guid);
      return recv_getResourceData();
    }

    public void send_getResourceData(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceData", TMessageType.CALL, ++seqid_));
      getResourceData_args args = new getResourceData_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public byte[] recv_getResourceData() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceData failed: out of sequence response");
      }
      getResourceData_result result = new getResourceData_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceData failed: unknown result");
    }

    public com.evernote.edam.type.Resource getResourceByHash(String authenticationToken, String noteGuid, byte[] contentHash, boolean withData, boolean withRecognition, boolean withAlternateData) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceByHash(authenticationToken, noteGuid, contentHash, withData, withRecognition, withAlternateData);
      return recv_getResourceByHash();
    }

    public void send_getResourceByHash(String authenticationToken, String noteGuid, byte[] contentHash, boolean withData, boolean withRecognition, boolean withAlternateData) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceByHash", TMessageType.CALL, ++seqid_));
      getResourceByHash_args args = new getResourceByHash_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNoteGuid(noteGuid);
      args.setContentHash(contentHash);
      args.setWithData(withData);
      args.setWithRecognition(withRecognition);
      args.setWithAlternateData(withAlternateData);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Resource recv_getResourceByHash() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceByHash failed: out of sequence response");
      }
      getResourceByHash_result result = new getResourceByHash_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceByHash failed: unknown result");
    }

    public byte[] getResourceRecognition(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceRecognition(authenticationToken, guid);
      return recv_getResourceRecognition();
    }

    public void send_getResourceRecognition(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceRecognition", TMessageType.CALL, ++seqid_));
      getResourceRecognition_args args = new getResourceRecognition_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public byte[] recv_getResourceRecognition() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceRecognition failed: out of sequence response");
      }
      getResourceRecognition_result result = new getResourceRecognition_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceRecognition failed: unknown result");
    }

    public byte[] getResourceAlternateData(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceAlternateData(authenticationToken, guid);
      return recv_getResourceAlternateData();
    }

    public void send_getResourceAlternateData(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceAlternateData", TMessageType.CALL, ++seqid_));
      getResourceAlternateData_args args = new getResourceAlternateData_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public byte[] recv_getResourceAlternateData() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceAlternateData failed: out of sequence response");
      }
      getResourceAlternateData_result result = new getResourceAlternateData_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceAlternateData failed: unknown result");
    }

    public com.evernote.edam.type.ResourceAttributes getResourceAttributes(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getResourceAttributes(authenticationToken, guid);
      return recv_getResourceAttributes();
    }

    public void send_getResourceAttributes(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getResourceAttributes", TMessageType.CALL, ++seqid_));
      getResourceAttributes_args args = new getResourceAttributes_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.ResourceAttributes recv_getResourceAttributes() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getResourceAttributes failed: out of sequence response");
      }
      getResourceAttributes_result result = new getResourceAttributes_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getResourceAttributes failed: unknown result");
    }

    public com.evernote.edam.type.Notebook getPublicNotebook(int userId, String publicUri) throws com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_getPublicNotebook(userId, publicUri);
      return recv_getPublicNotebook();
    }

    public void send_getPublicNotebook(int userId, String publicUri) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getPublicNotebook", TMessageType.CALL, ++seqid_));
      getPublicNotebook_args args = new getPublicNotebook_args();
      args.setUserId(userId);
      args.setPublicUri(publicUri);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.Notebook recv_getPublicNotebook() throws com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getPublicNotebook failed: out of sequence response");
      }
      getPublicNotebook_result result = new getPublicNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getPublicNotebook failed: unknown result");
    }

    public com.evernote.edam.type.SharedNotebook createSharedNotebook(String authenticationToken, com.evernote.edam.type.SharedNotebook sharedNotebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_createSharedNotebook(authenticationToken, sharedNotebook);
      return recv_createSharedNotebook();
    }

    public void send_createSharedNotebook(String authenticationToken, com.evernote.edam.type.SharedNotebook sharedNotebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createSharedNotebook", TMessageType.CALL, ++seqid_));
      createSharedNotebook_args args = new createSharedNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSharedNotebook(sharedNotebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.SharedNotebook recv_createSharedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createSharedNotebook failed: out of sequence response");
      }
      createSharedNotebook_result result = new createSharedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createSharedNotebook failed: unknown result");
    }

    public int updateSharedNotebook(String authenticationToken, com.evernote.edam.type.SharedNotebook sharedNotebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_updateSharedNotebook(authenticationToken, sharedNotebook);
      return recv_updateSharedNotebook();
    }

    public void send_updateSharedNotebook(String authenticationToken, com.evernote.edam.type.SharedNotebook sharedNotebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateSharedNotebook", TMessageType.CALL, ++seqid_));
      updateSharedNotebook_args args = new updateSharedNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSharedNotebook(sharedNotebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateSharedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateSharedNotebook failed: out of sequence response");
      }
      updateSharedNotebook_result result = new updateSharedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateSharedNotebook failed: unknown result");
    }

    public int setSharedNotebookRecipientSettings(String authenticationToken, long sharedNotebookId, com.evernote.edam.type.SharedNotebookRecipientSettings recipientSettings) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_setSharedNotebookRecipientSettings(authenticationToken, sharedNotebookId, recipientSettings);
      return recv_setSharedNotebookRecipientSettings();
    }

    public void send_setSharedNotebookRecipientSettings(String authenticationToken, long sharedNotebookId, com.evernote.edam.type.SharedNotebookRecipientSettings recipientSettings) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("setSharedNotebookRecipientSettings", TMessageType.CALL, ++seqid_));
      setSharedNotebookRecipientSettings_args args = new setSharedNotebookRecipientSettings_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSharedNotebookId(sharedNotebookId);
      args.setRecipientSettings(recipientSettings);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_setSharedNotebookRecipientSettings() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "setSharedNotebookRecipientSettings failed: out of sequence response");
      }
      setSharedNotebookRecipientSettings_result result = new setSharedNotebookRecipientSettings_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "setSharedNotebookRecipientSettings failed: unknown result");
    }

    public int sendMessageToSharedNotebookMembers(String authenticationToken, String notebookGuid, String messageText, List<String> recipients) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_sendMessageToSharedNotebookMembers(authenticationToken, notebookGuid, messageText, recipients);
      return recv_sendMessageToSharedNotebookMembers();
    }

    public void send_sendMessageToSharedNotebookMembers(String authenticationToken, String notebookGuid, String messageText, List<String> recipients) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("sendMessageToSharedNotebookMembers", TMessageType.CALL, ++seqid_));
      sendMessageToSharedNotebookMembers_args args = new sendMessageToSharedNotebookMembers_args();
      args.setAuthenticationToken(authenticationToken);
      args.setNotebookGuid(notebookGuid);
      args.setMessageText(messageText);
      args.setRecipients(recipients);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_sendMessageToSharedNotebookMembers() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "sendMessageToSharedNotebookMembers failed: out of sequence response");
      }
      sendMessageToSharedNotebookMembers_result result = new sendMessageToSharedNotebookMembers_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "sendMessageToSharedNotebookMembers failed: unknown result");
    }

    public List<com.evernote.edam.type.SharedNotebook> listSharedNotebooks(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_listSharedNotebooks(authenticationToken);
      return recv_listSharedNotebooks();
    }

    public void send_listSharedNotebooks(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listSharedNotebooks", TMessageType.CALL, ++seqid_));
      listSharedNotebooks_args args = new listSharedNotebooks_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.SharedNotebook> recv_listSharedNotebooks() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listSharedNotebooks failed: out of sequence response");
      }
      listSharedNotebooks_result result = new listSharedNotebooks_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listSharedNotebooks failed: unknown result");
    }

    public int expungeSharedNotebooks(String authenticationToken, List<Long> sharedNotebookIds) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_expungeSharedNotebooks(authenticationToken, sharedNotebookIds);
      return recv_expungeSharedNotebooks();
    }

    public void send_expungeSharedNotebooks(String authenticationToken, List<Long> sharedNotebookIds) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeSharedNotebooks", TMessageType.CALL, ++seqid_));
      expungeSharedNotebooks_args args = new expungeSharedNotebooks_args();
      args.setAuthenticationToken(authenticationToken);
      args.setSharedNotebookIds(sharedNotebookIds);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeSharedNotebooks() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeSharedNotebooks failed: out of sequence response");
      }
      expungeSharedNotebooks_result result = new expungeSharedNotebooks_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeSharedNotebooks failed: unknown result");
    }

    public com.evernote.edam.type.LinkedNotebook createLinkedNotebook(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_createLinkedNotebook(authenticationToken, linkedNotebook);
      return recv_createLinkedNotebook();
    }

    public void send_createLinkedNotebook(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("createLinkedNotebook", TMessageType.CALL, ++seqid_));
      createLinkedNotebook_args args = new createLinkedNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setLinkedNotebook(linkedNotebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.LinkedNotebook recv_createLinkedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "createLinkedNotebook failed: out of sequence response");
      }
      createLinkedNotebook_result result = new createLinkedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "createLinkedNotebook failed: unknown result");
    }

    public int updateLinkedNotebook(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_updateLinkedNotebook(authenticationToken, linkedNotebook);
      return recv_updateLinkedNotebook();
    }

    public void send_updateLinkedNotebook(String authenticationToken, com.evernote.edam.type.LinkedNotebook linkedNotebook) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("updateLinkedNotebook", TMessageType.CALL, ++seqid_));
      updateLinkedNotebook_args args = new updateLinkedNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setLinkedNotebook(linkedNotebook);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_updateLinkedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "updateLinkedNotebook failed: out of sequence response");
      }
      updateLinkedNotebook_result result = new updateLinkedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "updateLinkedNotebook failed: unknown result");
    }

    public List<com.evernote.edam.type.LinkedNotebook> listLinkedNotebooks(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_listLinkedNotebooks(authenticationToken);
      return recv_listLinkedNotebooks();
    }

    public void send_listLinkedNotebooks(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("listLinkedNotebooks", TMessageType.CALL, ++seqid_));
      listLinkedNotebooks_args args = new listLinkedNotebooks_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public List<com.evernote.edam.type.LinkedNotebook> recv_listLinkedNotebooks() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "listLinkedNotebooks failed: out of sequence response");
      }
      listLinkedNotebooks_result result = new listLinkedNotebooks_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "listLinkedNotebooks failed: unknown result");
    }

    public int expungeLinkedNotebook(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_expungeLinkedNotebook(authenticationToken, guid);
      return recv_expungeLinkedNotebook();
    }

    public void send_expungeLinkedNotebook(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("expungeLinkedNotebook", TMessageType.CALL, ++seqid_));
      expungeLinkedNotebook_args args = new expungeLinkedNotebook_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public int recv_expungeLinkedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "expungeLinkedNotebook failed: out of sequence response");
      }
      expungeLinkedNotebook_result result = new expungeLinkedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "expungeLinkedNotebook failed: unknown result");
    }

    public com.evernote.edam.userstore.AuthenticationResult authenticateToSharedNotebook(String shareKey, String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_authenticateToSharedNotebook(shareKey, authenticationToken);
      return recv_authenticateToSharedNotebook();
    }

    public void send_authenticateToSharedNotebook(String shareKey, String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("authenticateToSharedNotebook", TMessageType.CALL, ++seqid_));
      authenticateToSharedNotebook_args args = new authenticateToSharedNotebook_args();
      args.setShareKey(shareKey);
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.userstore.AuthenticationResult recv_authenticateToSharedNotebook() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "authenticateToSharedNotebook failed: out of sequence response");
      }
      authenticateToSharedNotebook_result result = new authenticateToSharedNotebook_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "authenticateToSharedNotebook failed: unknown result");
    }

    public com.evernote.edam.type.SharedNotebook getSharedNotebookByAuth(String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_getSharedNotebookByAuth(authenticationToken);
      return recv_getSharedNotebookByAuth();
    }

    public void send_getSharedNotebookByAuth(String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getSharedNotebookByAuth", TMessageType.CALL, ++seqid_));
      getSharedNotebookByAuth_args args = new getSharedNotebookByAuth_args();
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.type.SharedNotebook recv_getSharedNotebookByAuth() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "getSharedNotebookByAuth failed: out of sequence response");
      }
      getSharedNotebookByAuth_result result = new getSharedNotebookByAuth_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getSharedNotebookByAuth failed: unknown result");
    }

    public void emailNote(String authenticationToken, NoteEmailParameters parameters) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_emailNote(authenticationToken, parameters);
      recv_emailNote();
    }

    public void send_emailNote(String authenticationToken, NoteEmailParameters parameters) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("emailNote", TMessageType.CALL, ++seqid_));
      emailNote_args args = new emailNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setParameters(parameters);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public void recv_emailNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "emailNote failed: out of sequence response");
      }
      emailNote_result result = new emailNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      return;
    }

    public String shareNote(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_shareNote(authenticationToken, guid);
      return recv_shareNote();
    }

    public void send_shareNote(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("shareNote", TMessageType.CALL, ++seqid_));
      shareNote_args args = new shareNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public String recv_shareNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "shareNote failed: out of sequence response");
      }
      shareNote_result result = new shareNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "shareNote failed: unknown result");
    }

    public void stopSharingNote(String authenticationToken, String guid) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_stopSharingNote(authenticationToken, guid);
      recv_stopSharingNote();
    }

    public void send_stopSharingNote(String authenticationToken, String guid) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("stopSharingNote", TMessageType.CALL, ++seqid_));
      stopSharingNote_args args = new stopSharingNote_args();
      args.setAuthenticationToken(authenticationToken);
      args.setGuid(guid);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public void recv_stopSharingNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "stopSharingNote failed: out of sequence response");
      }
      stopSharingNote_result result = new stopSharingNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      return;
    }

    public com.evernote.edam.userstore.AuthenticationResult authenticateToSharedNote(String guid, String noteKey, String authenticationToken) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      send_authenticateToSharedNote(guid, noteKey, authenticationToken);
      return recv_authenticateToSharedNote();
    }

    public void send_authenticateToSharedNote(String guid, String noteKey, String authenticationToken) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("authenticateToSharedNote", TMessageType.CALL, ++seqid_));
      authenticateToSharedNote_args args = new authenticateToSharedNote_args();
      args.setGuid(guid);
      args.setNoteKey(noteKey);
      args.setAuthenticationToken(authenticationToken);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public com.evernote.edam.userstore.AuthenticationResult recv_authenticateToSharedNote() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMNotFoundException, com.evernote.edam.error.EDAMSystemException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "authenticateToSharedNote failed: out of sequence response");
      }
      authenticateToSharedNote_result result = new authenticateToSharedNote_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "authenticateToSharedNote failed: unknown result");
    }

    public RelatedResult findRelated(String authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec) throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      send_findRelated(authenticationToken, query, resultSpec);
      return recv_findRelated();
    }

    public void send_findRelated(String authenticationToken, RelatedQuery query, RelatedResultSpec resultSpec) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("findRelated", TMessageType.CALL, ++seqid_));
      findRelated_args args = new findRelated_args();
      args.setAuthenticationToken(authenticationToken);
      args.setQuery(query);
      args.setResultSpec(resultSpec);
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }

    public RelatedResult recv_findRelated() throws com.evernote.edam.error.EDAMUserException, com.evernote.edam.error.EDAMSystemException, com.evernote.edam.error.EDAMNotFoundException, TException
    {
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      if (msg.seqid != seqid_) {
        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "findRelated failed: out of sequence response");
      }
      findRelated_result result = new findRelated_result();
      result.read(iprot_);
      iprot_.readMessageEnd();
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.userException != null) {
        throw result.userException;
      }
      if (result.systemException != null) {
        throw result.systemException;
      }
      if (result.notFoundException != null) {
        throw result.notFoundException;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "findRelated failed: unknown result");
    }

  }
  private static class getSyncState_args implements TBase<getSyncState_args>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncState_args");

    private static final TField AUTHENTICATION_TOKEN_FIELD_DESC = new TField("authenticationToken", TType.STRING, (short)1);

    private String authenticationToken;


    // isset id assignments

    public getSyncState_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncState_args(getSyncState_args other) {
      if (other.isSetAuthenticationToken()) {
        this.authenticationToken = other.authenticationToken;
      }
    }

    public getSyncState_args deepCopy() {
      return new getSyncState_args(this);
    }

    public void clear() {
      this.authenticationToken = null;
    }

    public void setAuthenticationToken(String authenticationToken) {
      this.authenticationToken = authenticationToken;
    }

    /** Returns true if field authenticationToken is set (has been asigned a value) and false otherwise */
    public boolean isSetAuthenticationToken() {
      return this.authenticationToken != null;
    }

    public int compareTo(getSyncState_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncState_args typedOther = (getSyncState_args)other;

      lastComparison = Boolean.valueOf(isSetAuthenticationToken()).compareTo(typedOther.isSetAuthenticationToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthenticationToken()) {        lastComparison = TBaseHelper.compareTo(this.authenticationToken, typedOther.authenticationToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public void read(TProtocol iprot) throws TException {
      TField field;
      iprot.readStructBegin();
      while (true)
      {
        field = iprot.readFieldBegin();
        if (field.type == TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 1: // AUTHENTICATION_TOKEN
            if (field.type == TType.STRING) {
              this.authenticationToken = iprot.readString();
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, field.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      validate();
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.authenticationToken != null) {
        oprot.writeFieldBegin(AUTHENTICATION_TOKEN_FIELD_DESC);
        oprot.writeString(this.authenticationToken);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  private static class getSyncState_result implements TBase<getSyncState_result>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncState_result");

    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
    private static final TField USER_EXCEPTION_FIELD_DESC = new TField("userException", TType.STRUCT, (short)1);
    private static final TField SYSTEM_EXCEPTION_FIELD_DESC = new TField("systemException", TType.STRUCT, (short)2);

    private SyncState success;
    private com.evernote.edam.error.EDAMUserException userException;
    private com.evernote.edam.error.EDAMSystemException systemException;


    // isset id assignments

    public getSyncState_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncState_result(getSyncState_result other) {
      if (other.isSetSuccess()) {
        this.success = new SyncState(other.success);
      }
      if (other.isSetUserException()) {
        this.userException = new com.evernote.edam.error.EDAMUserException(other.userException);
      }
      if (other.isSetSystemException()) {
        this.systemException = new com.evernote.edam.error.EDAMSystemException(other.systemException);
      }
    }

    public getSyncState_result deepCopy() {
      return new getSyncState_result(this);
    }

    public void clear() {
      this.success = null;
      this.userException = null;
      this.systemException = null;
    }

    /** Returns true if field success is set (has been asigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    /** Returns true if field userException is set (has been asigned a value) and false otherwise */
    public boolean isSetUserException() {
      return this.userException != null;
    }

    /** Returns true if field systemException is set (has been asigned a value) and false otherwise */
    public boolean isSetSystemException() {
      return this.systemException != null;
    }

    public int compareTo(getSyncState_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncState_result typedOther = (getSyncState_result)other;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {        lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetUserException()).compareTo(typedOther.isSetUserException());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserException()) {        lastComparison = TBaseHelper.compareTo(this.userException, typedOther.userException);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetSystemException()).compareTo(typedOther.isSetSystemException());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSystemException()) {        lastComparison = TBaseHelper.compareTo(this.systemException, typedOther.systemException);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public void read(TProtocol iprot) throws TException {
      TField field;
      iprot.readStructBegin();
      while (true)
      {
        field = iprot.readFieldBegin();
        if (field.type == TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == TType.STRUCT) {
              this.success = new SyncState();
              this.success.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 1: // USER_EXCEPTION
            if (field.type == TType.STRUCT) {
              this.userException = new com.evernote.edam.error.EDAMUserException();
              this.userException.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 2: // SYSTEM_EXCEPTION
            if (field.type == TType.STRUCT) {
              this.systemException = new com.evernote.edam.error.EDAMSystemException();
              this.systemException.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, field.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      validate();
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        this.success.write(oprot);
        oprot.writeFieldEnd();
      } else if (this.isSetUserException()) {
        oprot.writeFieldBegin(USER_EXCEPTION_FIELD_DESC);
        this.userException.write(oprot);
        oprot.writeFieldEnd();
      } else if (this.isSetSystemException()) {
        oprot.writeFieldBegin(SYSTEM_EXCEPTION_FIELD_DESC);
        this.systemException.write(oprot);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  private static class getSyncStateWithMetrics_args implements TBase<getSyncStateWithMetrics_args>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncStateWithMetrics_args");

    private static final TField AUTHENTICATION_TOKEN_FIELD_DESC = new TField("authenticationToken", TType.STRING, (short)1);
    private static final TField CLIENT_METRICS_FIELD_DESC = new TField("clientMetrics", TType.STRUCT, (short)2);

    private String authenticationToken;
    private ClientUsageMetrics clientMetrics;


    // isset id assignments

    public getSyncStateWithMetrics_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncStateWithMetrics_args(getSyncStateWithMetrics_args other) {
      if (other.isSetAuthenticationToken()) {
        this.authenticationToken = other.authenticationToken;
      }
      if (other.isSetClientMetrics()) {
        this.clientMetrics = new ClientUsageMetrics(other.clientMetrics);
      }
    }

    public getSyncStateWithMetrics_args deepCopy() {
      return new getSyncStateWithMetrics_args(this);
    }

    public void clear() {
      this.authenticationToken = null;
      this.clientMetrics = null;
    }

    public void setAuthenticationToken(String authenticationToken) {
      this.authenticationToken = authenticationToken;
    }

    /** Returns true if field authenticationToken is set (has been asigned a value) and false otherwise */
    public boolean isSetAuthenticationToken() {
      return this.authenticationToken != null;
    }

    public void setClientMetrics(ClientUsageMetrics clientMetrics) {
      this.clientMetrics = clientMetrics;
    }

    /** Returns true if field clientMetrics is set (has been asigned a value) and false otherwise */
    public boolean isSetClientMetrics() {
      return this.clientMetrics != null;
    }

    public int compareTo(getSyncStateWithMetrics_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncStateWithMetrics_args typedOther = (getSyncStateWithMetrics_args)other;

      lastComparison = Boolean.valueOf(isSetAuthenticationToken()).compareTo(typedOther.isSetAuthenticationToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthenticationToken()) {        lastComparison = TBaseHelper.compareTo(this.authenticationToken, typedOther.authenticationToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetClientMetrics()).compareTo(typedOther.isSetClientMetrics());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetClientMetrics()) {        lastComparison = TBaseHelper.compareTo(this.clientMetrics, typedOther.clientMetrics);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public void read(TProtocol iprot) throws TException {
      TField field;
      iprot.readStructBegin();
      while (true)
      {
        field = iprot.readFieldBegin();
        if (field.type == TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 1: // AUTHENTICATION_TOKEN
            if (field.type == TType.STRING) {
              this.authenticationToken = iprot.readString();
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 2: // CLIENT_METRICS
            if (field.type == TType.STRUCT) {
              this.clientMetrics = new ClientUsageMetrics();
              this.clientMetrics.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, field.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      validate();
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.authenticationToken != null) {
        oprot.writeFieldBegin(AUTHENTICATION_TOKEN_FIELD_DESC);
        oprot.writeString(this.authenticationToken);
        oprot.writeFieldEnd();
      }
      if (this.clientMetrics != null) {
        oprot.writeFieldBegin(CLIENT_METRICS_FIELD_DESC);
        this.clientMetrics.write(oprot);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  private static class getSyncStateWithMetrics_result implements TBase<getSyncStateWithMetrics_result>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncStateWithMetrics_result");

    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
    private static final TField USER_EXCEPTION_FIELD_DESC = new TField("userException", TType.STRUCT, (short)1);
    private static final TField SYSTEM_EXCEPTION_FIELD_DESC = new TField("systemException", TType.STRUCT, (short)2);

    private SyncState success;
    private com.evernote.edam.error.EDAMUserException userException;
    private com.evernote.edam.error.EDAMSystemException systemException;


    // isset id assignments

    public getSyncStateWithMetrics_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncStateWithMetrics_result(getSyncStateWithMetrics_result other) {
      if (other.isSetSuccess()) {
        this.success = new SyncState(other.success);
      }
      if (other.isSetUserException()) {
        this.userException = new com.evernote.edam.error.EDAMUserException(other.userException);
      }
      if (other.isSetSystemException()) {
        this.systemException = new com.evernote.edam.error.EDAMSystemException(other.systemException);
      }
    }

    public getSyncStateWithMetrics_result deepCopy() {
      return new getSyncStateWithMetrics_result(this);
    }

    public void clear() {
      this.success = null;
      this.userException = null;
      this.systemException = null;
    }

    /** Returns true if field success is set (has been asigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    /** Returns true if field userException is set (has been asigned a value) and false otherwise */
    public boolean isSetUserException() {
      return this.userException != null;
    }

    /** Returns true if field systemException is set (has been asigned a value) and false otherwise */
    public boolean isSetSystemException() {
      return this.systemException != null;
    }

    public int compareTo(getSyncStateWithMetrics_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncStateWithMetrics_result typedOther = (getSyncStateWithMetrics_result)other;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {        lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetUserException()).compareTo(typedOther.isSetUserException());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserException()) {        lastComparison = TBaseHelper.compareTo(this.userException, typedOther.userException);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetSystemException()).compareTo(typedOther.isSetSystemException());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSystemException()) {        lastComparison = TBaseHelper.compareTo(this.systemException, typedOther.systemException);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public void read(TProtocol iprot) throws TException {
      TField field;
      iprot.readStructBegin();
      while (true)
      {
        field = iprot.readFieldBegin();
        if (field.type == TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == TType.STRUCT) {
              this.success = new SyncState();
              this.success.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 1: // USER_EXCEPTION
            if (field.type == TType.STRUCT) {
              this.userException = new com.evernote.edam.error.EDAMUserException();
              this.userException.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 2: // SYSTEM_EXCEPTION
            if (field.type == TType.STRUCT) {
              this.systemException = new com.evernote.edam.error.EDAMSystemException();
              this.systemException.read(iprot);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, field.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      validate();
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        this.success.write(oprot);
        oprot.writeFieldEnd();
      } else if (this.isSetUserException()) {
        oprot.writeFieldBegin(USER_EXCEPTION_FIELD_DESC);
        this.userException.write(oprot);
        oprot.writeFieldEnd();
      } else if (this.isSetSystemException()) {
        oprot.writeFieldBegin(SYSTEM_EXCEPTION_FIELD_DESC);
        this.systemException.write(oprot);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  private static class getSyncChunk_args implements TBase<getSyncChunk_args>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncChunk_args");

    private static final TField AUTHENTICATION_TOKEN_FIELD_DESC = new TField("authenticationToken", TType.STRING, (short)1);
    private static final TField AFTER_USN_FIELD_DESC = new TField("afterUSN", TType.I32, (short)2);
    private static final TField MAX_ENTRIES_FIELD_DESC = new TField("maxEntries", TType.I32, (short)3);
    private static final TField FULL_SYNC_ONLY_FIELD_DESC = new TField("fullSyncOnly", TType.BOOL, (short)4);

    private String authenticationToken;
    private int afterUSN;
    private int maxEntries;
    private boolean fullSyncOnly;


    // isset id assignments
    private static final int __AFTERUSN_ISSET_ID = 0;
    private static final int __MAXENTRIES_ISSET_ID = 1;
    private static final int __FULLSYNCONLY_ISSET_ID = 2;
    private boolean[] __isset_vector = new boolean[3];

    public getSyncChunk_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncChunk_args(getSyncChunk_args other) {
      System.arraycopy(other.__isset_vector, 0, __isset_vector, 0, other.__isset_vector.length);
      if (other.isSetAuthenticationToken()) {
        this.authenticationToken = other.authenticationToken;
      }
      this.afterUSN = other.afterUSN;
      this.maxEntries = other.maxEntries;
      this.fullSyncOnly = other.fullSyncOnly;
    }

    public getSyncChunk_args deepCopy() {
      return new getSyncChunk_args(this);
    }

    public void clear() {
      this.authenticationToken = null;
      setAfterUSNIsSet(false);
      this.afterUSN = 0;
      setMaxEntriesIsSet(false);
      this.maxEntries = 0;
      setFullSyncOnlyIsSet(false);
      this.fullSyncOnly = false;
    }

    public void setAuthenticationToken(String authenticationToken) {
      this.authenticationToken = authenticationToken;
    }

    /** Returns true if field authenticationToken is set (has been asigned a value) and false otherwise */
    public boolean isSetAuthenticationToken() {
      return this.authenticationToken != null;
    }

    public void setAfterUSN(int afterUSN) {
      this.afterUSN = afterUSN;
      setAfterUSNIsSet(true);
    }

    /** Returns true if field afterUSN is set (has been asigned a value) and false otherwise */
    public boolean isSetAfterUSN() {
      return __isset_vector[__AFTERUSN_ISSET_ID];
    }

    public void setAfterUSNIsSet(boolean value) {
      __isset_vector[__AFTERUSN_ISSET_ID] = value;
    }

    public void setMaxEntries(int maxEntries) {
      this.maxEntries = maxEntries;
      setMaxEntriesIsSet(true);
    }

    /** Returns true if field maxEntries is set (has been asigned a value) and false otherwise */
    public boolean isSetMaxEntries() {
      return __isset_vector[__MAXENTRIES_ISSET_ID];
    }

    public void setMaxEntriesIsSet(boolean value) {
      __isset_vector[__MAXENTRIES_ISSET_ID] = value;
    }

    public void setFullSyncOnly(boolean fullSyncOnly) {
      this.fullSyncOnly = fullSyncOnly;
      setFullSyncOnlyIsSet(true);
    }

    /** Returns true if field fullSyncOnly is set (has been asigned a value) and false otherwise */
    public boolean isSetFullSyncOnly() {
      return __isset_vector[__FULLSYNCONLY_ISSET_ID];
    }

    public void setFullSyncOnlyIsSet(boolean value) {
      __isset_vector[__FULLSYNCONLY_ISSET_ID] = value;
    }

    public int compareTo(getSyncChunk_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncChunk_args typedOther = (getSyncChunk_args)other;

      lastComparison = Boolean.valueOf(isSetAuthenticationToken()).compareTo(typedOther.isSetAuthenticationToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthenticationToken()) {        lastComparison = TBaseHelper.compareTo(this.authenticationToken, typedOther.authenticationToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAfterUSN()).compareTo(typedOther.isSetAfterUSN());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAfterUSN()) {        lastComparison = TBaseHelper.compareTo(this.afterUSN, typedOther.afterUSN);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetMaxEntries()).compareTo(typedOther.isSetMaxEntries());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetMaxEntries()) {        lastComparison = TBaseHelper.compareTo(this.maxEntries, typedOther.maxEntries);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFullSyncOnly()).compareTo(typedOther.isSetFullSyncOnly());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFullSyncOnly()) {        lastComparison = TBaseHelper.compareTo(this.fullSyncOnly, typedOther.fullSyncOnly);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public void read(TProtocol iprot) throws TException {
      TField field;
      iprot.readStructBegin();
      while (true)
      {
        field = iprot.readFieldBegin();
        if (field.type == TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 1: // AUTHENTICATION_TOKEN
            if (field.type == TType.STRING) {
              this.authenticationToken = iprot.readString();
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 2: // AFTER_USN
            if (field.type == TType.I32) {
              this.afterUSN = iprot.readI32();
              setAfterUSNIsSet(true);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 3: // MAX_ENTRIES
            if (field.type == TType.I32) {
              this.maxEntries = iprot.readI32();
              setMaxEntriesIsSet(true);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 4: // FULL_SYNC_ONLY
            if (field.type == TType.BOOL) {
              this.fullSyncOnly = iprot.readBool();
              setFullSyncOnlyIsSet(true);
            } else { 
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, field.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      validate();
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.authenticationToken != null) {
        oprot.writeFieldBegin(AUTHENTICATION_TOKEN_FIELD_DESC);
        oprot.writeString(this.authenticationToken);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(AFTER_USN_FIELD_DESC);
      oprot.writeI32(this.afterUSN);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(MAX_ENTRIES_FIELD_DESC);
      oprot.writeI32(this.maxEntries);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(FULL_SYNC_ONLY_FIELD_DESC);
      oprot.writeBool(this.fullSyncOnly);
      oprot.writeFieldEnd();
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  private static class getSyncChunk_result implements TBase<getSyncChunk_result>, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getSyncChunk_result");

    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
    private static final TField USER_EXCEPTION_FIELD_DESC = new TField("userException", TType.STRUCT, (short)1);
    private static final TField SYSTEM_EXCEPTION_FIELD_DESC = new TField("systemException", TType.STRUCT, (short)2);

    private SyncChunk success;
    private com.evernote.edam.error.EDAMUserException userException;
    private com.evernote.edam.error.EDAMSystemException systemException;


    // isset id assignments

    public getSyncChunk_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getSyncChunk_result(getSyncChunk_result other) {
      if (other.isSetSuccess()) {
        this.success = new SyncChunk(other.success);
      }
      if (other.isSetUserException()) {
        this.userException = new com.evernote.edam.error.EDAMUserException(other.userException);
      }
      if (other.isSetSystemException()) {
        this.systemException = new com.evernote.edam.error.EDAMSystemException(other.systemException);
      }
    }

    public getSyncChunk_result deepCopy() {
      return new getSyncChunk_result(this);
    }

    public void clear() {
      this.success = null;
      this.userException = null;
      this.systemException = null;
    }

    /** Returns true if field success is set (has been asigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    /** Returns true if field userException is set (has been asigned a value) and false otherwise */
    public boolean isSetUserException() {
      return this.userException != null;
    }

    /** Returns true if field systemException is set (has been asigned a value) and false otherwise */
    public boolean isSetSystemException() {
      return this.systemException != null;
    }

    public int compareTo(getSyncChunk_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;
      getSyncChunk_result typedOther = (getSyncChunk_result)other;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {        lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetUserException()).compareTo(typedOther.isSetUserException());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserException()) {        lastComparison = TBaseHelper.compareTo(this.userException, typedOther.userException);
        if (lastComparison != 0) {
          return lastComparison</