Net-Evernote

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

Revision history for Net-Evernote

0.07    2013-08-09
	added tests and methods. See t/

0.06    2012-5-13
        add the findNotes method

0.05    2011-12-27
        add the getNote method

0.04    2011-12-25
        add the delNote method

0.03    2011-12-17
        update the dependence

0.02    2011-12-15
        Make the content string ENML compatible

0.01    2011-12-14
        First version, a very begin release

MANIFEST  view on Meta::CPAN

Changes
lib/Net/Evernote/EDAMErrors/Constants.pm
lib/Net/Evernote/EDAMErrors/Types.pm
lib/Net/Evernote/EDAMLimits/Constants.pm
lib/Net/Evernote/EDAMLimits/Types.pm
lib/Net/Evernote/EDAMNoteStore/Constants.pm
lib/Net/Evernote/EDAMNoteStore/NoteStore.pm
lib/Net/Evernote/EDAMNoteStore/Types.pm
lib/Net/Evernote/EDAMTypes/Constants.pm
lib/Net/Evernote/EDAMTypes/Types.pm
lib/Net/Evernote/EDAMUserStore/Constants.pm
lib/Net/Evernote/EDAMUserStore/Types.pm
lib/Net/Evernote/EDAMUserStore/UserStore.pm
lib/Net/Evernote.pm
lib/Net/Evernote/Note.pm
lib/Net/Evernote/Notebook.pm
lib/Net/Evernote/Tag.pm
Makefile.PL
MANIFEST
README
t/00-authentication.t
t/01-note.t
t/02-notebook.t
t/03-tag.t
t/Common.pm
t/manifest.t
META.yml                                 Module YAML meta-data (added by MakeMaker)
META.json                                Module JSON meta-data (added by MakeMaker)

META.json  view on Meta::CPAN

{
   "abstract" : "Perl API for Evernote",
   "author" : [
      "David Collins<davidcollins4481@gmail.com>, Ken Peng <shorttag@gmail.com>"
   ],
   "dynamic_config" : 1,
   "generated_by" : "ExtUtils::MakeMaker version 6.72, CPAN::Meta::Converter version 2.120351",
   "license" : [
      "perl_5"
   ],
   "meta-spec" : {
      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
      "version" : "2"
   },
   "name" : "Net-Evernote",
   "no_index" : {
      "directory" : [
         "t",
         "inc"
      ]
   },
   "prereqs" : {
      "build" : {
         "requires" : {
            "ExtUtils::MakeMaker" : "0"
         }
      },
      "configure" : {
         "requires" : {
            "ExtUtils::MakeMaker" : "0"
         }
      },
      "runtime" : {
         "requires" : {
            "Crypt::SSLeay" : "0",
            "IO::String" : "0",
            "LWP::UserAgent" : "0",
            "Test::More" : "0",
            "Thrift::XS" : "0"
         }
      }
   },
   "release_status" : "stable",
   "version" : "0.081"
}

META.yml  view on Meta::CPAN

---
abstract: 'Perl API for Evernote'
author:
  - 'David Collins<davidcollins4481@gmail.com>, Ken Peng <shorttag@gmail.com>'
build_requires:
  ExtUtils::MakeMaker: 0
configure_requires:
  ExtUtils::MakeMaker: 0
dynamic_config: 1
generated_by: 'ExtUtils::MakeMaker version 6.72, CPAN::Meta::Converter version 2.120351'
license: perl
meta-spec:
  url: http://module-build.sourceforge.net/META-spec-v1.4.html
  version: 1.4
name: Net-Evernote
no_index:
  directory:
    - t
    - inc
requires:
  Crypt::SSLeay: 0
  IO::String: 0
  LWP::UserAgent: 0
  Test::More: 0
  Thrift::XS: 0
version: 0.081

Makefile.PL  view on Meta::CPAN

use 5.006;
use strict;
use warnings;
use ExtUtils::MakeMaker;

WriteMakefile(
    NAME                => 'Net::Evernote',
    AUTHOR              => q{David Collins<davidcollins4481@gmail.com>, Ken Peng <shorttag@gmail.com>},
    VERSION_FROM        => 'lib/Net/Evernote.pm',
    ABSTRACT_FROM       => 'lib/Net/Evernote.pm',
    ($ExtUtils::MakeMaker::VERSION >= 6.3002
      ? ('LICENSE'=> 'perl')
      : ()),
    PL_FILES            => {},
    PREREQ_PM => {
        'Test::More' => 0,
        'LWP::UserAgent' => 0,
        'IO::String' => 0,
        'Crypt::SSLeay' => 0,
        'Thrift::XS' => 0,
    },
    dist                => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
    clean               => { FILES => 'Net-Evernote-*' },
);

README  view on Meta::CPAN

Net-Evernote

Access the Evernote API with a developer token and perform some (still basic) tasks.


INSTALLATION

To install this module, run the following commands:

	perl Makefile.PL
	make
	make test
	make install

SUPPORT AND DOCUMENTATION

After installing, you can find documentation for this module with the
perldoc command.

    perldoc Net::Evernote

You can also look for information at:

    RT, CPAN's request tracker (report bugs here)
        http://rt.cpan.org/NoAuth/Bugs.html?Dist=Net-Evernote

    AnnoCPAN, Annotated CPAN documentation
        http://annocpan.org/dist/Net-Evernote

    CPAN Ratings
        http://cpanratings.perl.org/d/Net-Evernote

    Search CPAN
        http://search.cpan.org/dist/Net-Evernote/


LICENSE AND COPYRIGHT

Copyright (C) 2013 David Collins, Ken Peng

This program is free software; you can redistribute it and/or modify it
under the terms of either: the GNU General Public License as published
by the Free Software Foundation; or the Artistic License.

See http://dev.perl.org/licenses/ for more information.

lib/Net/Evernote.pm  view on Meta::CPAN

package Net::Evernote;

BEGIN {
    my $module_dir = $INC{'Net/Evernote.pm'};
    $module_dir =~ s/Evernote\.pm$//;
    unshift @INC,$module_dir;
}

use warnings;
use strict;
use Exception::Class (
    'Net::Evernote::EDAMTest::Exception::ExceptionWrapper',
    'Net::Evernote::EDAMTest::Exception::FileIOError',
);

use LWP::Protocol::https; # it is not needed to 'use' here, but it must be installed.
        # if it is not installed, an error (Thrift::TException object) is to be thrown.
use Thrift::HttpClient;
use Thrift::BinaryProtocol;
use Net::Evernote::EDAMTypes::Types;  # you must do `use' Net::Evernote::EDAMTypes::Types and Net::Evernote::EDAMErrors::Types
use Net::Evernote::EDAMErrors::Types; # before doing `use' Net::Evernote::EDAMUserStore::UserStore or Net::Evernote::EDAMNoteStore::NoteStore
use Net::Evernote::EDAMUserStore::UserStore;
use Net::Evernote::EDAMNoteStore::NoteStore;
use Net::Evernote::EDAMUserStore::Constants;
use Evernote::Note;
use Evernote::Tag;
use Evernote::Notebook;
our $VERSION = '0.081';

sub new {
    my ($class, $args) = @_;
    my $authentication_token = $$args{authentication_token};
    my $debug = $ENV{DEBUG};
    my $evernote_host;

    if ($$args{use_sandbox}) {
        $evernote_host = 'sandbox.evernote.com';
    } else {
        $evernote_host = 'www.evernote.com';
    }

    my $user_store_url = 'https://' . $evernote_host . '/edam/user';
    my $result;
    my $note_store;

    eval {

        local $SIG{__DIE__} = sub {
            my ( $err ) = @_;
            if ( not ( blessed $err && $err->isa('Exception::Class::Base') ) ) {
                Net::Evernote::EDAMTest::Exception::ExceptionWrapper->throw( error => $err );
            }
        };

        my $user_store_client = Thrift::HttpClient->new( $user_store_url );
        # default timeout value may be too short
        $user_store_client->setSendTimeout( 2000 );
        $user_store_client->setRecvTimeout( 10000 );
        my $user_store_prot = Thrift::BinaryProtocol->new( $user_store_client );
        my $user_store = Net::Evernote::EDAMUserStore::UserStoreClient->new( $user_store_prot, $user_store_prot );

        my $version_ok = $user_store->checkVersion( 'Evernote Net::Evernote::EDAMTest (Perl)',
            Net::Evernote::EDAMUserStore::Constants::EDAM_VERSION_MAJOR,
            Net::Evernote::EDAMUserStore::Constants::EDAM_VERSION_MINOR );

        if ( not $version_ok ) {
            printf "Evernote API version not up to date?\n";
            exit(1)
        }

        my $note_store_url = $user_store->getNoteStoreUrl( $authentication_token );

        warn "[INFO] note store url : $note_store_url \n" if $debug;
        my $note_store_client = Thrift::HttpClient->new( $note_store_url );
        # default timeout value may be too short
        $note_store_client->setSendTimeout( 2000 );
        $note_store_client->setRecvTimeout( 10000 );
        my $note_store_prot = Thrift::BinaryProtocol->new( $note_store_client );

        # search this class for API methods
        $note_store = Net::Evernote::EDAMNoteStore::NoteStoreClient->new( $note_store_prot, $note_store_prot );
    };

    if ($@) {
        my $err = $@;
        die "Code: " . $$err{'code'} . ', ' . $$err{'message'};
    }

    return bless { 
        debug             => $debug,
        _authentication_token  => $authentication_token,
        _notestore        => $note_store,
        _authenticated    => 1, # safe to assume if we've gotten this far?
    }, $class;
}

# TODO: make this is current
sub createNote {
    my ($self, $args) = @_;
    my $authentication_token = $self->{_authentication_token};
    my $client    = $self->{_notestore};

    my $title = $$args{title};
    my $content = $$args{content};
    my $created = $$args{created};

    # support notebook name?
    my $notebook_guid = $$args{notebook_guid};
    $content =~ s/\n/<br\/>/g;

     my $cont_encoded =<<EOF;
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
<en-note>
    $content
</en-note>
EOF

    my $note_args = {
        title   => $title,
        content => $cont_encoded,
    };

    $$note_args{created} = $created if $created;
    $$note_args{notebookGuid} = $notebook_guid if $notebook_guid;

    my $tags;

    # if tag already exists, just uses it and doesn't overwrite it.
    # Not sure if the eval is the best way to handle it but it seems
    # to do the job
    if (my $tag_args = $$args{tag_names}) {
        # make sure this is an array ref
        $tags = ref($tag_args) eq 'ARRAY' ? $tag_args: [$tag_args];
        map {
            my $tag = Net::Evernote::EDAMTypes::Tag->new({ name => $_ });
            eval {
                $client->createTag($authentication_token, $tag);
            };

            if ($@) {
                # dump 'em in a ditch
             }
        } @$tags;

         $$note_args{tagNames} = $tags;
    }

    if (my $tag_guids = $$args{tag_guids}) {
        my $guids = ref($tag_guids) eq 'ARRAY' ? $tag_guids : [$tag_guids];
        $$note_args{tagGuids} = $guids;
    }

    my $note = Net::Evernote::EDAMTypes::Note->new($note_args);

    return Net::Evernote::Note->new({
        _obj        => $client->createNote($authentication_token, $note),
        _notestore => $self->{_notestore},
        _authentication_token       => $authentication_token,
    });
}

sub deleteNote {
    my ($self, $args) = @_;
    my $guid = $$args{guid};

    my $authToken = $self->{_authentication_token};
    my $client = $self->{_notestore};

    $client->deleteNote($authToken,$guid);
}

sub getNote {
    my ($self, $args) = @_;
    my $guid = $$args{guid};

    my $client = $self->{_notestore};
    my $authentication_token = $self->{_authentication_token};

    return Net::Evernote::Note->new({
        _obj        => $client->getNote($authentication_token, $guid, 1),
        _notestore => $self->{_notestore},
        _authentication_token       => $authentication_token,
    });
}

sub getNotebook {
    my ($self, $args) = @_;
    my $guid = $$args{guid};

    my $client = $self->{_notestore};
    my $authentication_token = $self->{_authentication_token};

    my $notebook;
    eval {
        $notebook = Net::Evernote::Notebook->new({
            _obj        => $client->getNotebook($authentication_token, $guid, 1),
            _notestore => $self->{_notestore},
            _authentication_token       => $authentication_token,
        });
    };

    if (my $error = $@) {
        # notebook not found
        if (ref($error) eq 'Net::Evernote::EDAMNotFoundException') {
            return;
        }
    }

    return $notebook;
}

sub findNotes {
    my ($self, $args) = @_;
    my $string = $$args{string};
    my $offset = $$args{offset} || 0;
    my $maxNotes = $$args{maxCount} || 1;

    my $authentication_token = $self->{_authentication_token};

    my $stru = Net::Evernote::EDAMNoteStore::NoteFilter->new({ words => $string });
    my $client = $self->{_notestore};

    return $client->findNotes($authentication_token,$stru,$offset,$maxNotes);
}

sub listNotebooks {
    my $self = shift;
    my $client = $self->{_notestore};
    return $client->listNotebooks($self->{_authentication_token});
}

sub createNotebook {
    my ($self, $args) = @_;
    my $client = $self->{_notestore};
    my $notebook = Net::Evernote::EDAMTypes::Notebook->new({
        name => $$args{name},
    });

    return Net::Evernote::Notebook->new({
        _obj => $client->createNotebook($self->{_authentication_token}, $notebook),
        _notestore => $self->{_notestore},
    });
}

sub deleteNotebook {
    my ($self, $args) = @_;
    my $guid = $$args{guid};

    my $authToken = $self->{_authentication_token};
    my $client = $self->{_notestore};

    return $client->expungeNotebook($authToken,$guid);
}

sub authenticated {
    my $self = shift;
    return $self->{_authenticated};
}

sub createTag {
    my ($self, $args) = @_;
    my $authentication_token = $self->{_authentication_token};
    my $client    = $self->{_notestore};

    my $name = $$args{name};

    die "Name required to create tag\n" if !$name;

    my $tag = Net::Evernote::EDAMTypes::Tag->new({ name => $name });

    return Net::Evernote::Tag->new({
        _obj        => $client->createTag($authentication_token, $tag),
        _notestore => $self->{_notestore},
        _authentication_token  => $authentication_token,
    }); 
}

sub getTag {
    my ($self, $args) = @_;
    my $guid = $$args{guid};

    my $client = $self->{_notestore};
    my $authentication_token = $self->{_authentication_token};

    my $tag;

    eval {
        $tag = Net::Evernote::Tag->new({
            _obj        => $client->getTag($authentication_token, $guid, 1),
            _notestore => $self->{_notestore},
            _authentication_token       => $authentication_token,
        });
    };

    if (my $error = $@) {
        # tag not found
        if (ref($error) eq 'Net::Evernote::EDAMNotFoundException') {
            return;
        }
    }

    return $tag;

}

sub deleteTag {
    my ($self, $args) = @_;
    my $ns = $self->{_notestore};

    # FIXME: IS THIS EVEN POSSIBLE?
    # I don't see any code for this yet in Net::Evernote::EDAMNoteStore::NoteStore.pm

}

1;

=head1 NAME

Net::Evernote - Perl API for Evernote

=head1 VERSION

Version 0.06


=head1 SYNOPSIS

    use Net::Evernote;

    my $evernote = Net::Evernote->new({
        authentication_token => $authentication_token
    });

    # write a note
    my $res = $evernote->createNote({
        title => $title,
        content => $content
    });

    my $guid = $res->guid;

    # get the note
    my $thisNote = $evernote->getNote({ guid => $guid });
    print $thisNote->title,"\n";
    print $thisNote->content,"\n";

    # delete the note
    $evernote->deleteNote({ guid => $guid });

    # find notes
    my $search = $evernote->findNotes({ keywords => $keywords, offset => $offset, max_notes => 5 });
    for my $thisNote ( @{$search->notes} ) {
        print $thisNote->guid,"\n";
        print $thisNote->title,"\n";
    }

=head1 METHODS

More docs coming for this. 

=head1 SEE ALSO

http://www.evernote.com/about/developer/api/


=head1 AUTHOR

David Collins <davidcollins4481@gmail.com>

=head1 BUGS/LIMITATIONS

If you have found bugs, please send email to <davidcollins4481@gmail.com>


=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Net::Evernote


=head1 COPYRIGHT & LICENSE

Copyright 2013 David Collins, all rights reserved.

This program is free software; you can redistribute it and/or modify 
it under the same terms as Perl itself.

lib/Net/Evernote/EDAMErrors/Constants.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
package Net::Evernote::EDAMErrors::Constants;
require 5.6.0;
use strict;
use warnings;
use Thrift;


1;

lib/Net/Evernote/EDAMErrors/Types.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

package Net::Evernote::EDAMErrors::Net::Evernote::EDAMErrorCode;
use constant UNKNOWN => 1;
use constant BAD_DATA_FORMAT => 2;
use constant PERMISSION_DENIED => 3;
use constant INTERNAL_ERROR => 4;
use constant DATA_REQUIRED => 5;
use constant LIMIT_REACHED => 6;
use constant QUOTA_REACHED => 7;
use constant INVALID_AUTH => 8;
use constant AUTH_EXPIRED => 9;
use constant DATA_CONFLICT => 10;
use constant ENML_VALIDATION => 11;
use constant SHARD_UNAVAILABLE => 12;
use constant LEN_TOO_SHORT => 13;
use constant LEN_TOO_LONG => 14;
use constant TOO_FEW => 15;
use constant TOO_MANY => 16;
use constant UNSUPPORTED_OPERATION => 17;
package Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException;
use base qw(Thrift::TException);
use base qw(Class::Accessor);
Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->mk_accessors( qw( errorCode parameter ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{errorCode} = undef;
  $self->{parameter} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{errorCode}) {
      $self->{errorCode} = $vals->{errorCode};
    }
    if (defined $vals->{parameter}) {
      $self->{parameter} = $vals->{parameter};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Net::Evernote::EDAMUserException';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{errorCode});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{parameter});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Net::Evernote::EDAMUserException');
  if (defined $self->{errorCode}) {
    $xfer += $output->writeFieldBegin('errorCode', TType::I32, 1);
    $xfer += $output->writeI32($self->{errorCode});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{parameter}) {
    $xfer += $output->writeFieldBegin('parameter', TType::STRING, 2);
    $xfer += $output->writeString($self->{parameter});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException;
use base qw(Thrift::TException);
use base qw(Class::Accessor);
Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->mk_accessors( qw( errorCode message ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{errorCode} = undef;
  $self->{message} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{errorCode}) {
      $self->{errorCode} = $vals->{errorCode};
    }
    if (defined $vals->{message}) {
      $self->{message} = $vals->{message};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Net::Evernote::EDAMSystemException';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{errorCode});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{message});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Net::Evernote::EDAMSystemException');
  if (defined $self->{errorCode}) {
    $xfer += $output->writeFieldBegin('errorCode', TType::I32, 1);
    $xfer += $output->writeI32($self->{errorCode});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{message}) {
    $xfer += $output->writeFieldBegin('message', TType::STRING, 2);
    $xfer += $output->writeString($self->{message});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException;
use base qw(Thrift::TException);
use base qw(Class::Accessor);
Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->mk_accessors( qw( identifier key ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{identifier} = undef;
  $self->{key} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{identifier}) {
      $self->{identifier} = $vals->{identifier};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Net::Evernote::EDAMNotFoundException';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{identifier});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Net::Evernote::EDAMNotFoundException');
  if (defined $self->{identifier}) {
    $xfer += $output->writeFieldBegin('identifier', TType::STRING, 1);
    $xfer += $output->writeString($self->{identifier});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 2);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

1;

lib/Net/Evernote/EDAMLimits/Constants.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
package Net::Evernote::EDAMLimits::Constants;
require 5.6.0;
use strict;
use warnings;
use Thrift;


use constant EDAM_ATTRIBUTE_LEN_MIN => 1;

use constant EDAM_ATTRIBUTE_LEN_MAX => 4096;

use constant EDAM_ATTRIBUTE_REGEX => "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{1,4096}\$";

use constant EDAM_ATTRIBUTE_LIST_MAX => 100;

use constant EDAM_ATTRIBUTE_MAP_MAX => 100;

use constant EDAM_GUID_LEN_MIN => 36;

use constant EDAM_GUID_LEN_MAX => 36;

use constant EDAM_GUID_REGEX => "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\$";

use constant EDAM_EMAIL_LEN_MIN => 6;

use constant EDAM_EMAIL_LEN_MAX => 255;

use constant EDAM_EMAIL_LOCAL_REGEX => "^[A-Za-z0-9!#\$%&'*+/=?^_`{|}~-]+(\\.[A-Za-z0-9!#\$%&'*+/=?^_`{|}~-]+)*\$";

use constant EDAM_EMAIL_DOMAIN_REGEX => "^[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*\\.([A-Za-z]{2,})\$";

use constant EDAM_EMAIL_REGEX => "^[A-Za-z0-9!#\$%&'*+/=?^_`{|}~-]+(\\.[A-Za-z0-9!#\$%&'*+/=?^_`{|}~-]+)*\@[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*\\.([A-Za-z]{2,})\$";

use constant EDAM_TIMEZONE_LEN_MIN => 1;

use constant EDAM_TIMEZONE_LEN_MAX => 32;

use constant EDAM_TIMEZONE_REGEX => "^([A-Za-z_-]+(/[A-Za-z_-]+)*)|(GMT(-|\\+)[0-9]{1,2}(:[0-9]{2})?)\$";

use constant EDAM_MIME_LEN_MIN => 3;

use constant EDAM_MIME_LEN_MAX => 255;

use constant EDAM_MIME_REGEX => "^[A-Za-z]+/[A-Za-z0-9._+-]+\$";

use constant EDAM_MIME_TYPE_GIF => "image/gif";

use constant EDAM_MIME_TYPE_JPEG => "image/jpeg";

use constant EDAM_MIME_TYPE_PNG => "image/png";

use constant EDAM_MIME_TYPE_WAV => "audio/wav";

use constant EDAM_MIME_TYPE_MP3 => "audio/mpeg";

use constant EDAM_MIME_TYPE_AMR => "audio/amr";

use constant EDAM_MIME_TYPE_MP4_VIDEO => "video/mp4";

use constant EDAM_MIME_TYPE_INK => "application/vnd.evernote.ink";

use constant EDAM_MIME_TYPE_PDF => "application/pdf";

use constant EDAM_MIME_TYPE_DEFAULT => "application/octet-stream";

use constant EDAM_MIME_TYPES => [
"image/gif" => 1,
"image/jpeg" => 1,
"image/png" => 1,
"audio/wav" => 1,
"audio/mpeg" => 1,
"audio/amr" => 1,
"application/vnd.evernote.ink" => 1,
"application/pdf" => 1,
"video/mp4" => 1,
];

use constant EDAM_COMMERCE_SERVICE_GOOGLE => "Google";

use constant EDAM_COMMERCE_SERVICE_PAYPAL => "Paypal";

use constant EDAM_COMMERCE_SERVICE_GIFT => "Gift";

use constant EDAM_COMMERCE_SERVICE_TRIALPAY => "TrialPay";

use constant EDAM_COMMERCE_SERVICE_TRIAL => "Trial";

use constant EDAM_COMMERCE_SERVICE_GROUP => "Group";

use constant EDAM_COMMERCE_SERVICE_CYBERSOURCE => "CYBERSRC";

use constant EDAM_COMMERCE_DEFAULT_CURRENCY_COUNTRY_CODE => "USD";

use constant EDAM_SEARCH_QUERY_LEN_MIN => 0;

use constant EDAM_SEARCH_QUERY_LEN_MAX => 1024;

use constant EDAM_SEARCH_QUERY_REGEX => "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{0,1024}\$";

use constant EDAM_HASH_LEN => 16;

use constant EDAM_USER_USERNAME_LEN_MIN => 1;

use constant EDAM_USER_USERNAME_LEN_MAX => 64;

use constant EDAM_USER_USERNAME_REGEX => "^[a-z0-9]([a-z0-9_-]{0,62}[a-z0-9])?\$";

use constant EDAM_USER_NAME_LEN_MIN => 1;

use constant EDAM_USER_NAME_LEN_MAX => 255;

use constant EDAM_USER_NAME_REGEX => "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{1,255}\$";

use constant EDAM_TAG_NAME_LEN_MIN => 1;

use constant EDAM_TAG_NAME_LEN_MAX => 100;

use constant EDAM_TAG_NAME_REGEX => "^[^,\\p{Cc}\\p{Z}]([^,\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^,\\p{Cc}\\p{Z}])?\$";

use constant EDAM_NOTE_TITLE_LEN_MIN => 1;

use constant EDAM_NOTE_TITLE_LEN_MAX => 255;

use constant EDAM_NOTE_TITLE_REGEX => "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,253}[^\\p{Cc}\\p{Z}])?\$";

use constant EDAM_NOTE_CONTENT_LEN_MIN => 0;

use constant EDAM_NOTE_CONTENT_LEN_MAX => 5242880;

use constant EDAM_APPLICATIONDATA_NAME_LEN_MIN => 3;

use constant EDAM_APPLICATIONDATA_NAME_LEN_MAX => 32;

use constant EDAM_APPLICATIONDATA_VALUE_LEN_MIN => 0;

use constant EDAM_APPLICATIONDATA_VALUE_LEN_MAX => 4092;

use constant EDAM_APPLICATIONDATA_ENTRY_LEN_MAX => 4095;

use constant EDAM_APPLICATIONDATA_NAME_REGEX => "^[A-Za-z0-9_.-]{3,32}\$";

use constant EDAM_APPLICATIONDATA_VALUE_REGEX => "^[^\\p{Cc}]{0,4092}\$";

use constant EDAM_NOTEBOOK_NAME_LEN_MIN => 1;

use constant EDAM_NOTEBOOK_NAME_LEN_MAX => 100;

use constant EDAM_NOTEBOOK_NAME_REGEX => "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?\$";

use constant EDAM_NOTEBOOK_STACK_LEN_MIN => 1;

use constant EDAM_NOTEBOOK_STACK_LEN_MAX => 100;

use constant EDAM_NOTEBOOK_STACK_REGEX => "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?\$";

use constant EDAM_PUBLISHING_URI_LEN_MIN => 1;

use constant EDAM_PUBLISHING_URI_LEN_MAX => 255;

use constant EDAM_PUBLISHING_URI_REGEX => "^[a-zA-Z0-9.~_+-]{1,255}\$";

use constant EDAM_PUBLISHING_URI_PROHIBITED => [
".." => 1,
];

use constant EDAM_PUBLISHING_DESCRIPTION_LEN_MIN => 1;

use constant EDAM_PUBLISHING_DESCRIPTION_LEN_MAX => 200;

use constant EDAM_PUBLISHING_DESCRIPTION_REGEX => "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,198}[^\\p{Cc}\\p{Z}])?\$";

use constant EDAM_SAVED_SEARCH_NAME_LEN_MIN => 1;

use constant EDAM_SAVED_SEARCH_NAME_LEN_MAX => 100;

use constant EDAM_SAVED_SEARCH_NAME_REGEX => "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?\$";

use constant EDAM_USER_PASSWORD_LEN_MIN => 6;

use constant EDAM_USER_PASSWORD_LEN_MAX => 64;

use constant EDAM_USER_PASSWORD_REGEX => "^[A-Za-z0-9!#\$%&'()*+,./:;<=>?\@^_`{|}~\\[\\]\\\\-]{6,64}\$";

use constant EDAM_NOTE_TAGS_MAX => 100;

use constant EDAM_NOTE_RESOURCES_MAX => 1000;

use constant EDAM_USER_TAGS_MAX => 100000;

use constant EDAM_USER_SAVED_SEARCHES_MAX => 100;

use constant EDAM_USER_NOTES_MAX => 100000;

use constant EDAM_USER_NOTEBOOKS_MAX => 250;

use constant EDAM_USER_RECENT_MAILED_ADDRESSES_MAX => 10;

use constant EDAM_USER_MAIL_LIMIT_DAILY_FREE => 50;

use constant EDAM_USER_MAIL_LIMIT_DAILY_PREMIUM => 200;

use constant EDAM_USER_UPLOAD_LIMIT_FREE => 62914560;

use constant EDAM_USER_UPLOAD_LIMIT_PREMIUM => 1073741824;

use constant EDAM_NOTE_SIZE_MAX_FREE => 26214400;

use constant EDAM_NOTE_SIZE_MAX_PREMIUM => 52428800;

use constant EDAM_RESOURCE_SIZE_MAX_FREE => 26214400;

use constant EDAM_RESOURCE_SIZE_MAX_PREMIUM => 52428800;

use constant EDAM_USER_LINKED_NOTEBOOK_MAX => 100;

use constant EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX => 250;

use constant EDAM_NOTE_CONTENT_CLASS_LEN_MIN => 3;

use constant EDAM_NOTE_CONTENT_CLASS_LEN_MAX => 32;

use constant EDAM_HELLO_APP_CONTENT_CLASS_PREFIX => "evernote.hello.";

use constant EDAM_FOOD_APP_CONTENT_CLASS_PREFIX => "evernote.food.";

use constant EDAM_NOTE_CONTENT_CLASS_REGEX => "^[A-Za-z0-9_.-]{3,32}\$";

use constant EDAM_CONTENT_CLASS_HELLO_ENCOUNTER => "evernote.hello.encounter";

use constant EDAM_CONTENT_CLASS_HELLO_PROFILE => "evernote.hello.profile";

use constant EDAM_CONTENT_CLASS_FOOD_MEAL => "evernote.food.meal";

1;

lib/Net/Evernote/EDAMLimits/Types.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

1;

lib/Net/Evernote/EDAMNoteStore/Constants.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
package Net::Evernote::EDAMNoteStore::Constants;
require 5.6.0;
use strict;
use warnings;
use Thrift;


1;

lib/Net/Evernote/EDAMNoteStore/NoteStore.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

use Net::Evernote::EDAMNoteStore::Types;

# HELPER FUNCTIONS AND STRUCTURES

package Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSyncState_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSyncState_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSyncState_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::SyncState->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSyncState_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->mk_accessors( qw( authenticationToken afterUSN maxEntries fullSyncOnly ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{afterUSN} = undef;
  $self->{maxEntries} = undef;
  $self->{fullSyncOnly} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{afterUSN}) {
      $self->{afterUSN} = $vals->{afterUSN};
    }
    if (defined $vals->{maxEntries}) {
      $self->{maxEntries} = $vals->{maxEntries};
    }
    if (defined $vals->{fullSyncOnly}) {
      $self->{fullSyncOnly} = $vals->{fullSyncOnly};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSyncChunk_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{afterUSN});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxEntries});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{fullSyncOnly});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSyncChunk_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{afterUSN}) {
    $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 2);
    $xfer += $output->writeI32($self->{afterUSN});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxEntries}) {
    $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 3);
    $xfer += $output->writeI32($self->{maxEntries});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{fullSyncOnly}) {
    $xfer += $output->writeFieldBegin('fullSyncOnly', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{fullSyncOnly});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSyncChunk_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSyncChunk_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->mk_accessors( qw( authenticationToken afterUSN maxEntries filter ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{afterUSN} = undef;
  $self->{maxEntries} = undef;
  $self->{filter} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{afterUSN}) {
      $self->{afterUSN} = $vals->{afterUSN};
    }
    if (defined $vals->{maxEntries}) {
      $self->{maxEntries} = $vals->{maxEntries};
    }
    if (defined $vals->{filter}) {
      $self->{filter} = $vals->{filter};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getFilteredSyncChunk_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{afterUSN});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxEntries});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{filter} = Net::Evernote::EDAMNoteStore::SyncChunkFilter->new();
        $xfer += $self->{filter}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getFilteredSyncChunk_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{afterUSN}) {
    $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 2);
    $xfer += $output->writeI32($self->{afterUSN});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxEntries}) {
    $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 3);
    $xfer += $output->writeI32($self->{maxEntries});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{filter}) {
    $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 4);
    $xfer += $self->{filter}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getFilteredSyncChunk_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getFilteredSyncChunk_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->mk_accessors( qw( authenticationToken linkedNotebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{linkedNotebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{linkedNotebook}) {
      $self->{linkedNotebook} = $vals->{linkedNotebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getLinkedNotebookSyncState_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
        $xfer += $self->{linkedNotebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncState_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{linkedNotebook}) {
    $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
    $xfer += $self->{linkedNotebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getLinkedNotebookSyncState_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::SyncState->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncState_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->mk_accessors( qw( authenticationToken linkedNotebook afterUSN maxEntries fullSyncOnly ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{linkedNotebook} = undef;
  $self->{afterUSN} = undef;
  $self->{maxEntries} = undef;
  $self->{fullSyncOnly} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{linkedNotebook}) {
      $self->{linkedNotebook} = $vals->{linkedNotebook};
    }
    if (defined $vals->{afterUSN}) {
      $self->{afterUSN} = $vals->{afterUSN};
    }
    if (defined $vals->{maxEntries}) {
      $self->{maxEntries} = $vals->{maxEntries};
    }
    if (defined $vals->{fullSyncOnly}) {
      $self->{fullSyncOnly} = $vals->{fullSyncOnly};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getLinkedNotebookSyncChunk_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
        $xfer += $self->{linkedNotebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{afterUSN});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxEntries});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{fullSyncOnly});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncChunk_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{linkedNotebook}) {
    $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
    $xfer += $self->{linkedNotebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{afterUSN}) {
    $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 3);
    $xfer += $output->writeI32($self->{afterUSN});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxEntries}) {
    $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 4);
    $xfer += $output->writeI32($self->{maxEntries});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{fullSyncOnly}) {
    $xfer += $output->writeFieldBegin('fullSyncOnly', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{fullSyncOnly});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getLinkedNotebookSyncChunk_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncChunk_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listNotebooks_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listNotebooks_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listNotebooks_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size181 = 0;
          $self->{success} = [];
          my $_etype184 = 0;
          $xfer += $input->readListBegin(\$_etype184, \$_size181);
          for (my $_i185 = 0; $_i185 < $_size181; ++$_i185)
          {
            my $elem186 = undef;
            $elem186 = Net::Evernote::EDAMTypes::Notebook->new();
            $xfer += $elem186->read($input);
            push(@{$self->{success}},$elem186);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listNotebooks_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter187 (@{$self->{success}}) 
        {
          $xfer += ${iter187}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getDefaultNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getDefaultNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getDefaultNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getDefaultNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->mk_accessors( qw( authenticationToken notebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{notebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{notebook}) {
      $self->{notebook} = $vals->{notebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notebook} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{notebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebook}) {
    $xfer += $output->writeFieldBegin('notebook', TType::STRUCT, 2);
    $xfer += $self->{notebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->mk_accessors( qw( authenticationToken notebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{notebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{notebook}) {
      $self->{notebook} = $vals->{notebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notebook} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{notebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebook}) {
    $xfer += $output->writeFieldBegin('notebook', TType::STRUCT, 2);
    $xfer += $self->{notebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listTags_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listTags_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listTags_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listTags_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listTags_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size188 = 0;
          $self->{success} = [];
          my $_etype191 = 0;
          $xfer += $input->readListBegin(\$_etype191, \$_size188);
          for (my $_i192 = 0; $_i192 < $_size188; ++$_i192)
          {
            my $elem193 = undef;
            $elem193 = Net::Evernote::EDAMTypes::Tag->new();
            $xfer += $elem193->read($input);
            push(@{$self->{success}},$elem193);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listTags_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter194 (@{$self->{success}}) 
        {
          $xfer += ${iter194}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->mk_accessors( qw( authenticationToken notebookGuid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{notebookGuid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listTagsByNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listTagsByNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listTagsByNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size195 = 0;
          $self->{success} = [];
          my $_etype198 = 0;
          $xfer += $input->readListBegin(\$_etype198, \$_size195);
          for (my $_i199 = 0; $_i199 < $_size195; ++$_i199)
          {
            my $elem200 = undef;
            $elem200 = Net::Evernote::EDAMTypes::Tag->new();
            $xfer += $elem200->read($input);
            push(@{$self->{success}},$elem200);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listTagsByNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter201 (@{$self->{success}}) 
        {
          $xfer += ${iter201}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getTag_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getTag_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getTag_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getTag_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getTag_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Tag->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getTag_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createTag_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->mk_accessors( qw( authenticationToken tag ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{tag} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{tag}) {
      $self->{tag} = $vals->{tag};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createTag_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{tag} = Net::Evernote::EDAMTypes::Tag->new();
        $xfer += $self->{tag}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createTag_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tag}) {
    $xfer += $output->writeFieldBegin('tag', TType::STRUCT, 2);
    $xfer += $self->{tag}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createTag_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createTag_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Tag->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createTag_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->mk_accessors( qw( authenticationToken tag ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{tag} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{tag}) {
      $self->{tag} = $vals->{tag};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateTag_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{tag} = Net::Evernote::EDAMTypes::Tag->new();
        $xfer += $self->{tag}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateTag_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tag}) {
    $xfer += $output->writeFieldBegin('tag', TType::STRUCT, 2);
    $xfer += $self->{tag}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateTag_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateTag_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_untagAll_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_untagAll_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->mk_accessors( qw( ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_untagAll_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_untagAll_result');
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeTag_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeTag_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeTag_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeTag_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listSearches_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listSearches_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listSearches_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size202 = 0;
          $self->{success} = [];
          my $_etype205 = 0;
          $xfer += $input->readListBegin(\$_etype205, \$_size202);
          for (my $_i206 = 0; $_i206 < $_size202; ++$_i206)
          {
            my $elem207 = undef;
            $elem207 = Net::Evernote::EDAMTypes::SavedSearch->new();
            $xfer += $elem207->read($input);
            push(@{$self->{success}},$elem207);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listSearches_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter208 (@{$self->{success}}) 
        {
          $xfer += ${iter208}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSearch_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSearch_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSearch_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::SavedSearch->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSearch_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->mk_accessors( qw( authenticationToken search ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{search} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{search}) {
      $self->{search} = $vals->{search};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createSearch_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{search} = Net::Evernote::EDAMTypes::SavedSearch->new();
        $xfer += $self->{search}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createSearch_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{search}) {
    $xfer += $output->writeFieldBegin('search', TType::STRUCT, 2);
    $xfer += $self->{search}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createSearch_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::SavedSearch->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createSearch_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->mk_accessors( qw( authenticationToken search ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{search} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{search}) {
      $self->{search} = $vals->{search};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateSearch_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{search} = Net::Evernote::EDAMTypes::SavedSearch->new();
        $xfer += $self->{search}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateSearch_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{search}) {
    $xfer += $output->writeFieldBegin('search', TType::STRUCT, 2);
    $xfer += $self->{search}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateSearch_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateSearch_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeSearch_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeSearch_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeSearch_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeSearch_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->mk_accessors( qw( authenticationToken filter offset maxNotes ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{filter} = undef;
  $self->{offset} = undef;
  $self->{maxNotes} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{filter}) {
      $self->{filter} = $vals->{filter};
    }
    if (defined $vals->{offset}) {
      $self->{offset} = $vals->{offset};
    }
    if (defined $vals->{maxNotes}) {
      $self->{maxNotes} = $vals->{maxNotes};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNotes_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
        $xfer += $self->{filter}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{offset});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxNotes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNotes_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{filter}) {
    $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
    $xfer += $self->{filter}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{offset}) {
    $xfer += $output->writeFieldBegin('offset', TType::I32, 3);
    $xfer += $output->writeI32($self->{offset});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxNotes}) {
    $xfer += $output->writeFieldBegin('maxNotes', TType::I32, 4);
    $xfer += $output->writeI32($self->{maxNotes});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNotes_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::NoteList->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNotes_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->mk_accessors( qw( authenticationToken filter guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{filter} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{filter}) {
      $self->{filter} = $vals->{filter};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNoteOffset_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
        $xfer += $self->{filter}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNoteOffset_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{filter}) {
    $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
    $xfer += $self->{filter}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 3);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNoteOffset_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNoteOffset_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->mk_accessors( qw( authenticationToken filter offset maxNotes resultSpec ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{filter} = undef;
  $self->{offset} = undef;
  $self->{maxNotes} = undef;
  $self->{resultSpec} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{filter}) {
      $self->{filter} = $vals->{filter};
    }
    if (defined $vals->{offset}) {
      $self->{offset} = $vals->{offset};
    }
    if (defined $vals->{maxNotes}) {
      $self->{maxNotes} = $vals->{maxNotes};
    }
    if (defined $vals->{resultSpec}) {
      $self->{resultSpec} = $vals->{resultSpec};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNotesMetadata_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
        $xfer += $self->{filter}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{offset});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxNotes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{resultSpec} = Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec->new();
        $xfer += $self->{resultSpec}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNotesMetadata_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{filter}) {
    $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
    $xfer += $self->{filter}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{offset}) {
    $xfer += $output->writeFieldBegin('offset', TType::I32, 3);
    $xfer += $output->writeI32($self->{offset});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxNotes}) {
    $xfer += $output->writeFieldBegin('maxNotes', TType::I32, 4);
    $xfer += $output->writeI32($self->{maxNotes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{resultSpec}) {
    $xfer += $output->writeFieldBegin('resultSpec', TType::STRUCT, 5);
    $xfer += $self->{resultSpec}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNotesMetadata_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::NotesMetadataList->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNotesMetadata_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->mk_accessors( qw( authenticationToken filter withTrash ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{filter} = undef;
  $self->{withTrash} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{filter}) {
      $self->{filter} = $vals->{filter};
    }
    if (defined $vals->{withTrash}) {
      $self->{withTrash} = $vals->{withTrash};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNoteCounts_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
        $xfer += $self->{filter}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withTrash});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNoteCounts_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{filter}) {
    $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
    $xfer += $self->{filter}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withTrash}) {
    $xfer += $output->writeFieldBegin('withTrash', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{withTrash});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_findNoteCounts_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMNoteStore::NoteCollectionCounts->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_findNoteCounts_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->mk_accessors( qw( authenticationToken guid withContent withResourcesData withResourcesRecognition withResourcesAlternateData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{withContent} = undef;
  $self->{withResourcesData} = undef;
  $self->{withResourcesRecognition} = undef;
  $self->{withResourcesAlternateData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{withContent}) {
      $self->{withContent} = $vals->{withContent};
    }
    if (defined $vals->{withResourcesData}) {
      $self->{withResourcesData} = $vals->{withResourcesData};
    }
    if (defined $vals->{withResourcesRecognition}) {
      $self->{withResourcesRecognition} = $vals->{withResourcesRecognition};
    }
    if (defined $vals->{withResourcesAlternateData}) {
      $self->{withResourcesAlternateData} = $vals->{withResourcesAlternateData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withContent});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesRecognition});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesAlternateData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withContent}) {
    $xfer += $output->writeFieldBegin('withContent', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{withContent});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesData}) {
    $xfer += $output->writeFieldBegin('withResourcesData', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{withResourcesData});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesRecognition}) {
    $xfer += $output->writeFieldBegin('withResourcesRecognition', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{withResourcesRecognition});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesAlternateData}) {
    $xfer += $output->writeFieldBegin('withResourcesAlternateData', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{withResourcesAlternateData});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteApplicationData_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationData_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteApplicationData_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::LazyMap->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationData_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key value ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  $self->{value} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
    if (defined $vals->{value}) {
      $self->{value} = $vals->{value};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_setNoteApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{value});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_setNoteApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{value}) {
    $xfer += $output->writeFieldBegin('value', TType::STRING, 4);
    $xfer += $output->writeString($self->{value});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_setNoteApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_setNoteApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_unsetNoteApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_unsetNoteApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_unsetNoteApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_unsetNoteApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteContent_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteContent_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteContent_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteContent_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->mk_accessors( qw( authenticationToken guid noteOnly tokenizeForIndexing ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{noteOnly} = undef;
  $self->{tokenizeForIndexing} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{noteOnly}) {
      $self->{noteOnly} = $vals->{noteOnly};
    }
    if (defined $vals->{tokenizeForIndexing}) {
      $self->{tokenizeForIndexing} = $vals->{tokenizeForIndexing};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteSearchText_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{noteOnly});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{tokenizeForIndexing});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteSearchText_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteOnly}) {
    $xfer += $output->writeFieldBegin('noteOnly', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{noteOnly});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tokenizeForIndexing}) {
    $xfer += $output->writeFieldBegin('tokenizeForIndexing', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{tokenizeForIndexing});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteSearchText_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteSearchText_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceSearchText_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceSearchText_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceSearchText_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceSearchText_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteTagNames_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteTagNames_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteTagNames_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size209 = 0;
          $self->{success} = [];
          my $_etype212 = 0;
          $xfer += $input->readListBegin(\$_etype212, \$_size209);
          for (my $_i213 = 0; $_i213 < $_size209; ++$_i213)
          {
            my $elem214 = undef;
            $xfer += $input->readString(\$elem214);
            push(@{$self->{success}},$elem214);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteTagNames_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
      {
        foreach my $iter215 (@{$self->{success}}) 
        {
          $xfer += $output->writeString($iter215);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->mk_accessors( qw( authenticationToken note ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{note} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{note}) {
      $self->{note} = $vals->{note};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{note} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{note}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{note}) {
    $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
    $xfer += $self->{note}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->mk_accessors( qw( authenticationToken note ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{note} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{note}) {
      $self->{note} = $vals->{note};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{note} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{note}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{note}) {
    $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
    $xfer += $self->{note}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_deleteNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_deleteNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_deleteNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_deleteNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->mk_accessors( qw( authenticationToken noteGuids ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{noteGuids} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{noteGuids}) {
      $self->{noteGuids} = $vals->{noteGuids};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNotes_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size216 = 0;
          $self->{noteGuids} = [];
          my $_etype219 = 0;
          $xfer += $input->readListBegin(\$_etype219, \$_size216);
          for (my $_i220 = 0; $_i220 < $_size216; ++$_i220)
          {
            my $elem221 = undef;
            $xfer += $input->readString(\$elem221);
            push(@{$self->{noteGuids}},$elem221);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNotes_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuids}) {
    $xfer += $output->writeFieldBegin('noteGuids', TType::LIST, 2);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{noteGuids}}));
      {
        foreach my $iter222 (@{$self->{noteGuids}}) 
        {
          $xfer += $output->writeString($iter222);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeNotes_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeNotes_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeInactiveNotes_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeInactiveNotes_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeInactiveNotes_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeInactiveNotes_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->mk_accessors( qw( authenticationToken noteGuid toNotebookGuid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{noteGuid} = undef;
  $self->{toNotebookGuid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{noteGuid}) {
      $self->{noteGuid} = $vals->{noteGuid};
    }
    if (defined $vals->{toNotebookGuid}) {
      $self->{toNotebookGuid} = $vals->{toNotebookGuid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_copyNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{toNotebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_copyNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuid}) {
    $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{toNotebookGuid}) {
    $xfer += $output->writeFieldBegin('toNotebookGuid', TType::STRING, 3);
    $xfer += $output->writeString($self->{toNotebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_copyNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_copyNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->mk_accessors( qw( authenticationToken noteGuid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{noteGuid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{noteGuid}) {
      $self->{noteGuid} = $vals->{noteGuid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listNoteVersions_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listNoteVersions_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuid}) {
    $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteGuid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listNoteVersions_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size223 = 0;
          $self->{success} = [];
          my $_etype226 = 0;
          $xfer += $input->readListBegin(\$_etype226, \$_size223);
          for (my $_i227 = 0; $_i227 < $_size223; ++$_i227)
          {
            my $elem228 = undef;
            $elem228 = Net::Evernote::EDAMNoteStore::NoteVersionId->new();
            $xfer += $elem228->read($input);
            push(@{$self->{success}},$elem228);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listNoteVersions_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter229 (@{$self->{success}}) 
        {
          $xfer += ${iter229}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->mk_accessors( qw( authenticationToken noteGuid updateSequenceNum withResourcesData withResourcesRecognition withResourcesAlternateData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{noteGuid} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{withResourcesData} = undef;
  $self->{withResourcesRecognition} = undef;
  $self->{withResourcesAlternateData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{noteGuid}) {
      $self->{noteGuid} = $vals->{noteGuid};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{withResourcesData}) {
      $self->{withResourcesData} = $vals->{withResourcesData};
    }
    if (defined $vals->{withResourcesRecognition}) {
      $self->{withResourcesRecognition} = $vals->{withResourcesRecognition};
    }
    if (defined $vals->{withResourcesAlternateData}) {
      $self->{withResourcesAlternateData} = $vals->{withResourcesAlternateData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteVersion_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesRecognition});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withResourcesAlternateData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteVersion_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuid}) {
    $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 3);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesData}) {
    $xfer += $output->writeFieldBegin('withResourcesData', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{withResourcesData});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesRecognition}) {
    $xfer += $output->writeFieldBegin('withResourcesRecognition', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{withResourcesRecognition});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withResourcesAlternateData}) {
    $xfer += $output->writeFieldBegin('withResourcesAlternateData', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{withResourcesAlternateData});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getNoteVersion_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getNoteVersion_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResource_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->mk_accessors( qw( authenticationToken guid withData withRecognition withAttributes withAlternateData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{withData} = undef;
  $self->{withRecognition} = undef;
  $self->{withAttributes} = undef;
  $self->{withAlternateData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{withData}) {
      $self->{withData} = $vals->{withData};
    }
    if (defined $vals->{withRecognition}) {
      $self->{withRecognition} = $vals->{withRecognition};
    }
    if (defined $vals->{withAttributes}) {
      $self->{withAttributes} = $vals->{withAttributes};
    }
    if (defined $vals->{withAlternateData}) {
      $self->{withAlternateData} = $vals->{withAlternateData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResource_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withRecognition});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withAttributes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withAlternateData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResource_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withData}) {
    $xfer += $output->writeFieldBegin('withData', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{withData});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withRecognition}) {
    $xfer += $output->writeFieldBegin('withRecognition', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{withRecognition});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withAttributes}) {
    $xfer += $output->writeFieldBegin('withAttributes', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{withAttributes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withAlternateData}) {
    $xfer += $output->writeFieldBegin('withAlternateData', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{withAlternateData});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResource_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResource_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Resource->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResource_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceApplicationData_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationData_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceApplicationData_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::LazyMap->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationData_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key value ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  $self->{value} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
    if (defined $vals->{value}) {
      $self->{value} = $vals->{value};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_setResourceApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{value});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_setResourceApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{value}) {
    $xfer += $output->writeFieldBegin('value', TType::STRING, 4);
    $xfer += $output->writeString($self->{value});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_setResourceApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_setResourceApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  $self->{key} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{key}) {
      $self->{key} = $vals->{key};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_unsetResourceApplicationDataEntry_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{key});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_unsetResourceApplicationDataEntry_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{key}) {
    $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
    $xfer += $output->writeString($self->{key});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_unsetResourceApplicationDataEntry_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_unsetResourceApplicationDataEntry_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->mk_accessors( qw( authenticationToken resource ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{resource} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{resource}) {
      $self->{resource} = $vals->{resource};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateResource_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{resource} = Net::Evernote::EDAMTypes::Resource->new();
        $xfer += $self->{resource}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateResource_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{resource}) {
    $xfer += $output->writeFieldBegin('resource', TType::STRUCT, 2);
    $xfer += $self->{resource}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateResource_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateResource_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceData_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceData_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceData_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceData_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->mk_accessors( qw( authenticationToken noteGuid contentHash withData withRecognition withAlternateData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{noteGuid} = undef;
  $self->{contentHash} = undef;
  $self->{withData} = undef;
  $self->{withRecognition} = undef;
  $self->{withAlternateData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{noteGuid}) {
      $self->{noteGuid} = $vals->{noteGuid};
    }
    if (defined $vals->{contentHash}) {
      $self->{contentHash} = $vals->{contentHash};
    }
    if (defined $vals->{withData}) {
      $self->{withData} = $vals->{withData};
    }
    if (defined $vals->{withRecognition}) {
      $self->{withRecognition} = $vals->{withRecognition};
    }
    if (defined $vals->{withAlternateData}) {
      $self->{withAlternateData} = $vals->{withAlternateData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceByHash_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{contentHash});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withRecognition});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{withAlternateData});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceByHash_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuid}) {
    $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{contentHash}) {
    $xfer += $output->writeFieldBegin('contentHash', TType::STRING, 3);
    $xfer += $output->writeString($self->{contentHash});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withData}) {
    $xfer += $output->writeFieldBegin('withData', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{withData});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withRecognition}) {
    $xfer += $output->writeFieldBegin('withRecognition', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{withRecognition});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{withAlternateData}) {
    $xfer += $output->writeFieldBegin('withAlternateData', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{withAlternateData});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceByHash_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Resource->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceByHash_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceRecognition_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceRecognition_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceRecognition_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceRecognition_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceAlternateData_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceAlternateData_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceAlternateData_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceAlternateData_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceAttributes_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceAttributes_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getResourceAttributes_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::ResourceAttributes->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getResourceAttributes_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getAccountSize_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getAccountSize_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getAccountSize_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getAccountSize_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I64, 0);
    $xfer += $output->writeI64($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getAds_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->mk_accessors( qw( authenticationToken adParameters ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{adParameters} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{adParameters}) {
      $self->{adParameters} = $vals->{adParameters};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getAds_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{adParameters} = Net::Evernote::EDAMNoteStore::AdParameters->new();
        $xfer += $self->{adParameters}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getAds_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{adParameters}) {
    $xfer += $output->writeFieldBegin('adParameters', TType::STRUCT, 2);
    $xfer += $self->{adParameters}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getAds_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getAds_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size230 = 0;
          $self->{success} = [];
          my $_etype233 = 0;
          $xfer += $input->readListBegin(\$_etype233, \$_size230);
          for (my $_i234 = 0; $_i234 < $_size230; ++$_i234)
          {
            my $elem235 = undef;
            $elem235 = Net::Evernote::EDAMTypes::Ad->new();
            $xfer += $elem235->read($input);
            push(@{$self->{success}},$elem235);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getAds_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter236 (@{$self->{success}}) 
        {
          $xfer += ${iter236}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->mk_accessors( qw( authenticationToken adParameters ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{adParameters} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{adParameters}) {
      $self->{adParameters} = $vals->{adParameters};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getRandomAd_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{adParameters} = Net::Evernote::EDAMNoteStore::AdParameters->new();
        $xfer += $self->{adParameters}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getRandomAd_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{adParameters}) {
    $xfer += $output->writeFieldBegin('adParameters', TType::STRUCT, 2);
    $xfer += $self->{adParameters}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getRandomAd_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Ad->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getRandomAd_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->mk_accessors( qw( userId publicUri ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{userId} = undef;
  $self->{publicUri} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{userId}) {
      $self->{userId} = $vals->{userId};
    }
    if (defined $vals->{publicUri}) {
      $self->{publicUri} = $vals->{publicUri};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getPublicNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{userId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{publicUri});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getPublicNotebook_args');
  if (defined $self->{userId}) {
    $xfer += $output->writeFieldBegin('userId', TType::I32, 1);
    $xfer += $output->writeI32($self->{userId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{publicUri}) {
    $xfer += $output->writeFieldBegin('publicUri', TType::STRING, 2);
    $xfer += $output->writeString($self->{publicUri});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{systemException} = undef;
  $self->{notFoundException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getPublicNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getPublicNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 1);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->mk_accessors( qw( authenticationToken sharedNotebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{sharedNotebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{sharedNotebook}) {
      $self->{sharedNotebook} = $vals->{sharedNotebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createSharedNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{sharedNotebook} = Net::Evernote::EDAMTypes::SharedNotebook->new();
        $xfer += $self->{sharedNotebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createSharedNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sharedNotebook}) {
    $xfer += $output->writeFieldBegin('sharedNotebook', TType::STRUCT, 2);
    $xfer += $self->{sharedNotebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createSharedNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::SharedNotebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createSharedNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->mk_accessors( qw( authenticationToken notebookGuid messageText recipients ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{notebookGuid} = undef;
  $self->{messageText} = undef;
  $self->{recipients} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
    if (defined $vals->{messageText}) {
      $self->{messageText} = $vals->{messageText};
    }
    if (defined $vals->{recipients}) {
      $self->{recipients} = $vals->{recipients};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_sendMessageToSharedNotebookMembers_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{messageText});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size237 = 0;
          $self->{recipients} = [];
          my $_etype240 = 0;
          $xfer += $input->readListBegin(\$_etype240, \$_size237);
          for (my $_i241 = 0; $_i241 < $_size237; ++$_i241)
          {
            my $elem242 = undef;
            $xfer += $input->readString(\$elem242);
            push(@{$self->{recipients}},$elem242);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_sendMessageToSharedNotebookMembers_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{messageText}) {
    $xfer += $output->writeFieldBegin('messageText', TType::STRING, 3);
    $xfer += $output->writeString($self->{messageText});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{recipients}) {
    $xfer += $output->writeFieldBegin('recipients', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{recipients}}));
      {
        foreach my $iter243 (@{$self->{recipients}}) 
        {
          $xfer += $output->writeString($iter243);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_sendMessageToSharedNotebookMembers_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_sendMessageToSharedNotebookMembers_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listSharedNotebooks_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listSharedNotebooks_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listSharedNotebooks_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size244 = 0;
          $self->{success} = [];
          my $_etype247 = 0;
          $xfer += $input->readListBegin(\$_etype247, \$_size244);
          for (my $_i248 = 0; $_i248 < $_size244; ++$_i248)
          {
            my $elem249 = undef;
            $elem249 = Net::Evernote::EDAMTypes::SharedNotebook->new();
            $xfer += $elem249->read($input);
            push(@{$self->{success}},$elem249);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listSharedNotebooks_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter250 (@{$self->{success}}) 
        {
          $xfer += ${iter250}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->mk_accessors( qw( authenticationToken sharedNotebookIds ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{sharedNotebookIds} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{sharedNotebookIds}) {
      $self->{sharedNotebookIds} = $vals->{sharedNotebookIds};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeSharedNotebooks_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size251 = 0;
          $self->{sharedNotebookIds} = [];
          my $_etype254 = 0;
          $xfer += $input->readListBegin(\$_etype254, \$_size251);
          for (my $_i255 = 0; $_i255 < $_size251; ++$_i255)
          {
            my $elem256 = undef;
            $xfer += $input->readI64(\$elem256);
            push(@{$self->{sharedNotebookIds}},$elem256);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeSharedNotebooks_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sharedNotebookIds}) {
    $xfer += $output->writeFieldBegin('sharedNotebookIds', TType::LIST, 2);
    {
      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{sharedNotebookIds}}));
      {
        foreach my $iter257 (@{$self->{sharedNotebookIds}}) 
        {
          $xfer += $output->writeI64($iter257);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeSharedNotebooks_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeSharedNotebooks_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->mk_accessors( qw( authenticationToken linkedNotebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{linkedNotebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{linkedNotebook}) {
      $self->{linkedNotebook} = $vals->{linkedNotebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createLinkedNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
        $xfer += $self->{linkedNotebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createLinkedNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{linkedNotebook}) {
    $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
    $xfer += $self->{linkedNotebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_createLinkedNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_createLinkedNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->mk_accessors( qw( authenticationToken linkedNotebook ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{linkedNotebook} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{linkedNotebook}) {
      $self->{linkedNotebook} = $vals->{linkedNotebook};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateLinkedNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
        $xfer += $self->{linkedNotebook}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateLinkedNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{linkedNotebook}) {
    $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
    $xfer += $self->{linkedNotebook}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_updateLinkedNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_updateLinkedNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listLinkedNotebooks_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listLinkedNotebooks_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_listLinkedNotebooks_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size258 = 0;
          $self->{success} = [];
          my $_etype261 = 0;
          $xfer += $input->readListBegin(\$_etype261, \$_size258);
          for (my $_i262 = 0; $_i262 < $_size258; ++$_i262)
          {
            my $elem263 = undef;
            $elem263 = Net::Evernote::EDAMTypes::LinkedNotebook->new();
            $xfer += $elem263->read($input);
            push(@{$self->{success}},$elem263);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_listLinkedNotebooks_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
      {
        foreach my $iter264 (@{$self->{success}}) 
        {
          $xfer += ${iter264}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeLinkedNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeLinkedNotebook_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_expungeLinkedNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_expungeLinkedNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::I32, 0);
    $xfer += $output->writeI32($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->mk_accessors( qw( shareKey authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{shareKey} = undef;
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{shareKey}) {
      $self->{shareKey} = $vals->{shareKey};
    }
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_authenticateToSharedNotebook_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shareKey});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNotebook_args');
  if (defined $self->{shareKey}) {
    $xfer += $output->writeFieldBegin('shareKey', TType::STRING, 1);
    $xfer += $output->writeString($self->{shareKey});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 2);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_authenticateToSharedNotebook_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNotebook_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSharedNotebookByAuth_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSharedNotebookByAuth_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_getSharedNotebookByAuth_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::SharedNotebook->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_getSharedNotebookByAuth_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->mk_accessors( qw( authenticationToken parameters ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{parameters} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{parameters}) {
      $self->{parameters} = $vals->{parameters};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_emailNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{parameters} = Net::Evernote::EDAMNoteStore::NoteEmailParameters->new();
        $xfer += $self->{parameters}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_emailNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{parameters}) {
    $xfer += $output->writeFieldBegin('parameters', TType::STRUCT, 2);
    $xfer += $self->{parameters}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->mk_accessors( qw( ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_emailNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_emailNote_result');
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_shareNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_shareNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_shareNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_shareNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->mk_accessors( qw( authenticationToken guid ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  $self->{guid} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_stopSharingNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_stopSharingNote_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->mk_accessors( qw( ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_stopSharingNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_stopSharingNote_result');
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->mk_accessors( qw( guid noteKey ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{noteKey} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{noteKey}) {
      $self->{noteKey} = $vals->{noteKey};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_authenticateToSharedNote_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteKey});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNote_args');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteKey}) {
    $xfer += $output->writeFieldBegin('noteKey', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteKey});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteStore_authenticateToSharedNote_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNote_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteStoreIf;

use strict;


sub getSyncState{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

  die 'implement interface';
}

sub getFilteredSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $filter = shift;

  die 'implement interface';
}

sub getLinkedNotebookSyncState{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  die 'implement interface';
}

sub getLinkedNotebookSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

  die 'implement interface';
}

sub listNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getDefaultNotebook{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub createNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

  die 'implement interface';
}

sub updateNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

  die 'implement interface';
}

sub expungeNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub listTags{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub listTagsByNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;

  die 'implement interface';
}

sub getTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub createTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

  die 'implement interface';
}

sub updateTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

  die 'implement interface';
}

sub untagAll{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub expungeTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub listSearches{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub createSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

  die 'implement interface';
}

sub updateSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

  die 'implement interface';
}

sub expungeSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub findNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;

  die 'implement interface';
}

sub findNoteOffset{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $guid = shift;

  die 'implement interface';
}

sub findNotesMetadata{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;
  my $resultSpec = shift;

  die 'implement interface';
}

sub findNoteCounts{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $withTrash = shift;

  die 'implement interface';
}

sub getNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withContent = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

  die 'implement interface';
}

sub getNoteApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  die 'implement interface';
}

sub setNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

  die 'implement interface';
}

sub unsetNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  die 'implement interface';
}

sub getNoteContent{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getNoteSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $noteOnly = shift;
  my $tokenizeForIndexing = shift;

  die 'implement interface';
}

sub getResourceSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getNoteTagNames{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub createNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

  die 'implement interface';
}

sub updateNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

  die 'implement interface';
}

sub deleteNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub expungeNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub expungeNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuids = shift;

  die 'implement interface';
}

sub expungeInactiveNotes{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub copyNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $toNotebookGuid = shift;

  die 'implement interface';
}

sub listNoteVersions{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;

  die 'implement interface';
}

sub getNoteVersion{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $updateSequenceNum = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

  die 'implement interface';
}

sub getResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAttributes = shift;
  my $withAlternateData = shift;

  die 'implement interface';
}

sub getResourceApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  die 'implement interface';
}

sub setResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

  die 'implement interface';
}

sub unsetResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  die 'implement interface';
}

sub updateResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $resource = shift;

  die 'implement interface';
}

sub getResourceData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getResourceByHash{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $contentHash = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAlternateData = shift;

  die 'implement interface';
}

sub getResourceRecognition{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getResourceAlternateData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getResourceAttributes{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub getAccountSize{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getAds{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

  die 'implement interface';
}

sub getRandomAd{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

  die 'implement interface';
}

sub getPublicNotebook{
  my $self = shift;
  my $userId = shift;
  my $publicUri = shift;

  die 'implement interface';
}

sub createSharedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebook = shift;

  die 'implement interface';
}

sub sendMessageToSharedNotebookMembers{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;
  my $messageText = shift;
  my $recipients = shift;

  die 'implement interface';
}

sub listSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub expungeSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebookIds = shift;

  die 'implement interface';
}

sub createLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  die 'implement interface';
}

sub updateLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  die 'implement interface';
}

sub listLinkedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub expungeLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub authenticateToSharedNotebook{
  my $self = shift;
  my $shareKey = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getSharedNotebookByAuth{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub emailNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $parameters = shift;

  die 'implement interface';
}

sub shareNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub stopSharingNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  die 'implement interface';
}

sub authenticateToSharedNote{
  my $self = shift;
  my $guid = shift;
  my $noteKey = shift;

  die 'implement interface';
}

package Net::Evernote::EDAMNoteStore::NoteStoreRest;

use strict;


sub new {
  my ($classname, $impl) = @_;
  my $self     ={ impl => $impl };

  return bless($self,$classname);
}

sub getSyncState{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getSyncState($authenticationToken);
}

sub getSyncChunk{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
  my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
  my $fullSyncOnly = ($request->{'fullSyncOnly'}) ? $request->{'fullSyncOnly'} : undef;
  return $self->{impl}->getSyncChunk($authenticationToken, $afterUSN, $maxEntries, $fullSyncOnly);
}

sub getFilteredSyncChunk{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
  my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
  my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
  return $self->{impl}->getFilteredSyncChunk($authenticationToken, $afterUSN, $maxEntries, $filter);
}

sub getLinkedNotebookSyncState{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
  return $self->{impl}->getLinkedNotebookSyncState($authenticationToken, $linkedNotebook);
}

sub getLinkedNotebookSyncChunk{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
  my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
  my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
  my $fullSyncOnly = ($request->{'fullSyncOnly'}) ? $request->{'fullSyncOnly'} : undef;
  return $self->{impl}->getLinkedNotebookSyncChunk($authenticationToken, $linkedNotebook, $afterUSN, $maxEntries, $fullSyncOnly);
}

sub listNotebooks{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->listNotebooks($authenticationToken);
}

sub getNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getNotebook($authenticationToken, $guid);
}

sub getDefaultNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getDefaultNotebook($authenticationToken);
}

sub createNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $notebook = ($request->{'notebook'}) ? $request->{'notebook'} : undef;
  return $self->{impl}->createNotebook($authenticationToken, $notebook);
}

sub updateNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $notebook = ($request->{'notebook'}) ? $request->{'notebook'} : undef;
  return $self->{impl}->updateNotebook($authenticationToken, $notebook);
}

sub expungeNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->expungeNotebook($authenticationToken, $guid);
}

sub listTags{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->listTags($authenticationToken);
}

sub listTagsByNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $notebookGuid = ($request->{'notebookGuid'}) ? $request->{'notebookGuid'} : undef;
  return $self->{impl}->listTagsByNotebook($authenticationToken, $notebookGuid);
}

sub getTag{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getTag($authenticationToken, $guid);
}

sub createTag{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $tag = ($request->{'tag'}) ? $request->{'tag'} : undef;
  return $self->{impl}->createTag($authenticationToken, $tag);
}

sub updateTag{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $tag = ($request->{'tag'}) ? $request->{'tag'} : undef;
  return $self->{impl}->updateTag($authenticationToken, $tag);
}

sub untagAll{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->untagAll($authenticationToken, $guid);
}

sub expungeTag{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->expungeTag($authenticationToken, $guid);
}

sub listSearches{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->listSearches($authenticationToken);
}

sub getSearch{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getSearch($authenticationToken, $guid);
}

sub createSearch{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $search = ($request->{'search'}) ? $request->{'search'} : undef;
  return $self->{impl}->createSearch($authenticationToken, $search);
}

sub updateSearch{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $search = ($request->{'search'}) ? $request->{'search'} : undef;
  return $self->{impl}->updateSearch($authenticationToken, $search);
}

sub expungeSearch{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->expungeSearch($authenticationToken, $guid);
}

sub findNotes{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
  my $offset = ($request->{'offset'}) ? $request->{'offset'} : undef;
  my $maxNotes = ($request->{'maxNotes'}) ? $request->{'maxNotes'} : undef;
  return $self->{impl}->findNotes($authenticationToken, $filter, $offset, $maxNotes);
}

sub findNoteOffset{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->findNoteOffset($authenticationToken, $filter, $guid);
}

sub findNotesMetadata{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
  my $offset = ($request->{'offset'}) ? $request->{'offset'} : undef;
  my $maxNotes = ($request->{'maxNotes'}) ? $request->{'maxNotes'} : undef;
  my $resultSpec = ($request->{'resultSpec'}) ? $request->{'resultSpec'} : undef;
  return $self->{impl}->findNotesMetadata($authenticationToken, $filter, $offset, $maxNotes, $resultSpec);
}

sub findNoteCounts{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
  my $withTrash = ($request->{'withTrash'}) ? $request->{'withTrash'} : undef;
  return $self->{impl}->findNoteCounts($authenticationToken, $filter, $withTrash);
}

sub getNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $withContent = ($request->{'withContent'}) ? $request->{'withContent'} : undef;
  my $withResourcesData = ($request->{'withResourcesData'}) ? $request->{'withResourcesData'} : undef;
  my $withResourcesRecognition = ($request->{'withResourcesRecognition'}) ? $request->{'withResourcesRecognition'} : undef;
  my $withResourcesAlternateData = ($request->{'withResourcesAlternateData'}) ? $request->{'withResourcesAlternateData'} : undef;
  return $self->{impl}->getNote($authenticationToken, $guid, $withContent, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
}

sub getNoteApplicationData{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getNoteApplicationData($authenticationToken, $guid);
}

sub getNoteApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  return $self->{impl}->getNoteApplicationDataEntry($authenticationToken, $guid, $key);
}

sub setNoteApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  my $value = ($request->{'value'}) ? $request->{'value'} : undef;
  return $self->{impl}->setNoteApplicationDataEntry($authenticationToken, $guid, $key, $value);
}

sub unsetNoteApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  return $self->{impl}->unsetNoteApplicationDataEntry($authenticationToken, $guid, $key);
}

sub getNoteContent{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getNoteContent($authenticationToken, $guid);
}

sub getNoteSearchText{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $noteOnly = ($request->{'noteOnly'}) ? $request->{'noteOnly'} : undef;
  my $tokenizeForIndexing = ($request->{'tokenizeForIndexing'}) ? $request->{'tokenizeForIndexing'} : undef;
  return $self->{impl}->getNoteSearchText($authenticationToken, $guid, $noteOnly, $tokenizeForIndexing);
}

sub getResourceSearchText{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceSearchText($authenticationToken, $guid);
}

sub getNoteTagNames{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getNoteTagNames($authenticationToken, $guid);
}

sub createNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $note = ($request->{'note'}) ? $request->{'note'} : undef;
  return $self->{impl}->createNote($authenticationToken, $note);
}

sub updateNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $note = ($request->{'note'}) ? $request->{'note'} : undef;
  return $self->{impl}->updateNote($authenticationToken, $note);
}

sub deleteNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->deleteNote($authenticationToken, $guid);
}

sub expungeNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->expungeNote($authenticationToken, $guid);
}

sub expungeNotes{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $noteGuids = ($request->{'noteGuids'}) ? $request->{'noteGuids'} : undef;
  return $self->{impl}->expungeNotes($authenticationToken, $noteGuids);
}

sub expungeInactiveNotes{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->expungeInactiveNotes($authenticationToken);
}

sub copyNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
  my $toNotebookGuid = ($request->{'toNotebookGuid'}) ? $request->{'toNotebookGuid'} : undef;
  return $self->{impl}->copyNote($authenticationToken, $noteGuid, $toNotebookGuid);
}

sub listNoteVersions{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
  return $self->{impl}->listNoteVersions($authenticationToken, $noteGuid);
}

sub getNoteVersion{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
  my $updateSequenceNum = ($request->{'updateSequenceNum'}) ? $request->{'updateSequenceNum'} : undef;
  my $withResourcesData = ($request->{'withResourcesData'}) ? $request->{'withResourcesData'} : undef;
  my $withResourcesRecognition = ($request->{'withResourcesRecognition'}) ? $request->{'withResourcesRecognition'} : undef;
  my $withResourcesAlternateData = ($request->{'withResourcesAlternateData'}) ? $request->{'withResourcesAlternateData'} : undef;
  return $self->{impl}->getNoteVersion($authenticationToken, $noteGuid, $updateSequenceNum, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
}

sub getResource{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $withData = ($request->{'withData'}) ? $request->{'withData'} : undef;
  my $withRecognition = ($request->{'withRecognition'}) ? $request->{'withRecognition'} : undef;
  my $withAttributes = ($request->{'withAttributes'}) ? $request->{'withAttributes'} : undef;
  my $withAlternateData = ($request->{'withAlternateData'}) ? $request->{'withAlternateData'} : undef;
  return $self->{impl}->getResource($authenticationToken, $guid, $withData, $withRecognition, $withAttributes, $withAlternateData);
}

sub getResourceApplicationData{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceApplicationData($authenticationToken, $guid);
}

sub getResourceApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  return $self->{impl}->getResourceApplicationDataEntry($authenticationToken, $guid, $key);
}

sub setResourceApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  my $value = ($request->{'value'}) ? $request->{'value'} : undef;
  return $self->{impl}->setResourceApplicationDataEntry($authenticationToken, $guid, $key, $value);
}

sub unsetResourceApplicationDataEntry{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $key = ($request->{'key'}) ? $request->{'key'} : undef;
  return $self->{impl}->unsetResourceApplicationDataEntry($authenticationToken, $guid, $key);
}

sub updateResource{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $resource = ($request->{'resource'}) ? $request->{'resource'} : undef;
  return $self->{impl}->updateResource($authenticationToken, $resource);
}

sub getResourceData{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceData($authenticationToken, $guid);
}

sub getResourceByHash{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
  my $contentHash = ($request->{'contentHash'}) ? $request->{'contentHash'} : undef;
  my $withData = ($request->{'withData'}) ? $request->{'withData'} : undef;
  my $withRecognition = ($request->{'withRecognition'}) ? $request->{'withRecognition'} : undef;
  my $withAlternateData = ($request->{'withAlternateData'}) ? $request->{'withAlternateData'} : undef;
  return $self->{impl}->getResourceByHash($authenticationToken, $noteGuid, $contentHash, $withData, $withRecognition, $withAlternateData);
}

sub getResourceRecognition{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceRecognition($authenticationToken, $guid);
}

sub getResourceAlternateData{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceAlternateData($authenticationToken, $guid);
}

sub getResourceAttributes{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->getResourceAttributes($authenticationToken, $guid);
}

sub getAccountSize{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getAccountSize($authenticationToken);
}

sub getAds{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $adParameters = ($request->{'adParameters'}) ? $request->{'adParameters'} : undef;
  return $self->{impl}->getAds($authenticationToken, $adParameters);
}

sub getRandomAd{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $adParameters = ($request->{'adParameters'}) ? $request->{'adParameters'} : undef;
  return $self->{impl}->getRandomAd($authenticationToken, $adParameters);
}

sub getPublicNotebook{
  my ($self, $request) = @_;

  my $userId = ($request->{'userId'}) ? $request->{'userId'} : undef;
  my $publicUri = ($request->{'publicUri'}) ? $request->{'publicUri'} : undef;
  return $self->{impl}->getPublicNotebook($userId, $publicUri);
}

sub createSharedNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $sharedNotebook = ($request->{'sharedNotebook'}) ? $request->{'sharedNotebook'} : undef;
  return $self->{impl}->createSharedNotebook($authenticationToken, $sharedNotebook);
}

sub sendMessageToSharedNotebookMembers{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $notebookGuid = ($request->{'notebookGuid'}) ? $request->{'notebookGuid'} : undef;
  my $messageText = ($request->{'messageText'}) ? $request->{'messageText'} : undef;
  my $recipients = ($request->{'recipients'}) ? $request->{'recipients'} : undef;
  return $self->{impl}->sendMessageToSharedNotebookMembers($authenticationToken, $notebookGuid, $messageText, $recipients);
}

sub listSharedNotebooks{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->listSharedNotebooks($authenticationToken);
}

sub expungeSharedNotebooks{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $sharedNotebookIds = ($request->{'sharedNotebookIds'}) ? $request->{'sharedNotebookIds'} : undef;
  return $self->{impl}->expungeSharedNotebooks($authenticationToken, $sharedNotebookIds);
}

sub createLinkedNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
  return $self->{impl}->createLinkedNotebook($authenticationToken, $linkedNotebook);
}

sub updateLinkedNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
  return $self->{impl}->updateLinkedNotebook($authenticationToken, $linkedNotebook);
}

sub listLinkedNotebooks{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->listLinkedNotebooks($authenticationToken);
}

sub expungeLinkedNotebook{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->expungeLinkedNotebook($authenticationToken, $guid);
}

sub authenticateToSharedNotebook{
  my ($self, $request) = @_;

  my $shareKey = ($request->{'shareKey'}) ? $request->{'shareKey'} : undef;
  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->authenticateToSharedNotebook($shareKey, $authenticationToken);
}

sub getSharedNotebookByAuth{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getSharedNotebookByAuth($authenticationToken);
}

sub emailNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $parameters = ($request->{'parameters'}) ? $request->{'parameters'} : undef;
  return $self->{impl}->emailNote($authenticationToken, $parameters);
}

sub shareNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->shareNote($authenticationToken, $guid);
}

sub stopSharingNote{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  return $self->{impl}->stopSharingNote($authenticationToken, $guid);
}

sub authenticateToSharedNote{
  my ($self, $request) = @_;

  my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
  my $noteKey = ($request->{'noteKey'}) ? $request->{'noteKey'} : undef;
  return $self->{impl}->authenticateToSharedNote($guid, $noteKey);
}

package Net::Evernote::EDAMNoteStore::NoteStoreClient;


use base qw(Net::Evernote::EDAMNoteStore::NoteStoreIf);
sub new {
  my ($classname, $input, $output) = @_;
  my $self      = {};
  $self->{input}  = $input;
  $self->{output} = defined $output ? $output : $input;
  $self->{seqid}  = 0;
  return bless($self,$classname);
}

sub getSyncState{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getSyncState($authenticationToken);
  return $self->recv_getSyncState();
}

sub send_getSyncState{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getSyncState', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getSyncState{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getSyncState failed: unknown result";
}
sub getSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

    $self->send_getSyncChunk($authenticationToken, $afterUSN, $maxEntries, $fullSyncOnly);
  return $self->recv_getSyncChunk();
}

sub send_getSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

  $self->{output}->writeMessageBegin('getSyncChunk', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{afterUSN} = $afterUSN;
  $args->{maxEntries} = $maxEntries;
  $args->{fullSyncOnly} = $fullSyncOnly;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getSyncChunk{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getSyncChunk failed: unknown result";
}
sub getFilteredSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $filter = shift;

    $self->send_getFilteredSyncChunk($authenticationToken, $afterUSN, $maxEntries, $filter);
  return $self->recv_getFilteredSyncChunk();
}

sub send_getFilteredSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $filter = shift;

  $self->{output}->writeMessageBegin('getFilteredSyncChunk', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{afterUSN} = $afterUSN;
  $args->{maxEntries} = $maxEntries;
  $args->{filter} = $filter;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getFilteredSyncChunk{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getFilteredSyncChunk failed: unknown result";
}
sub getLinkedNotebookSyncState{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

    $self->send_getLinkedNotebookSyncState($authenticationToken, $linkedNotebook);
  return $self->recv_getLinkedNotebookSyncState();
}

sub send_getLinkedNotebookSyncState{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  $self->{output}->writeMessageBegin('getLinkedNotebookSyncState', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{linkedNotebook} = $linkedNotebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getLinkedNotebookSyncState{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getLinkedNotebookSyncState failed: unknown result";
}
sub getLinkedNotebookSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

    $self->send_getLinkedNotebookSyncChunk($authenticationToken, $linkedNotebook, $afterUSN, $maxEntries, $fullSyncOnly);
  return $self->recv_getLinkedNotebookSyncChunk();
}

sub send_getLinkedNotebookSyncChunk{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;
  my $afterUSN = shift;
  my $maxEntries = shift;
  my $fullSyncOnly = shift;

  $self->{output}->writeMessageBegin('getLinkedNotebookSyncChunk', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{linkedNotebook} = $linkedNotebook;
  $args->{afterUSN} = $afterUSN;
  $args->{maxEntries} = $maxEntries;
  $args->{fullSyncOnly} = $fullSyncOnly;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getLinkedNotebookSyncChunk{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getLinkedNotebookSyncChunk failed: unknown result";
}
sub listNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_listNotebooks($authenticationToken);
  return $self->recv_listNotebooks();
}

sub send_listNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('listNotebooks', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listNotebooks{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "listNotebooks failed: unknown result";
}
sub getNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getNotebook($authenticationToken, $guid);
  return $self->recv_getNotebook();
}

sub send_getNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNotebook failed: unknown result";
}
sub getDefaultNotebook{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getDefaultNotebook($authenticationToken);
  return $self->recv_getDefaultNotebook();
}

sub send_getDefaultNotebook{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getDefaultNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getDefaultNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getDefaultNotebook failed: unknown result";
}
sub createNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

    $self->send_createNotebook($authenticationToken, $notebook);
  return $self->recv_createNotebook();
}

sub send_createNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

  $self->{output}->writeMessageBegin('createNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{notebook} = $notebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "createNotebook failed: unknown result";
}
sub updateNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

    $self->send_updateNotebook($authenticationToken, $notebook);
  return $self->recv_updateNotebook();
}

sub send_updateNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebook = shift;

  $self->{output}->writeMessageBegin('updateNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{notebook} = $notebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "updateNotebook failed: unknown result";
}
sub expungeNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_expungeNotebook($authenticationToken, $guid);
  return $self->recv_expungeNotebook();
}

sub send_expungeNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('expungeNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "expungeNotebook failed: unknown result";
}
sub listTags{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_listTags($authenticationToken);
  return $self->recv_listTags();
}

sub send_listTags{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('listTags', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listTags{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "listTags failed: unknown result";
}
sub listTagsByNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;

    $self->send_listTagsByNotebook($authenticationToken, $notebookGuid);
  return $self->recv_listTagsByNotebook();
}

sub send_listTagsByNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;

  $self->{output}->writeMessageBegin('listTagsByNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{notebookGuid} = $notebookGuid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listTagsByNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "listTagsByNotebook failed: unknown result";
}
sub getTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getTag($authenticationToken, $guid);
  return $self->recv_getTag();
}

sub send_getTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getTag', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getTag{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getTag failed: unknown result";
}
sub createTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

    $self->send_createTag($authenticationToken, $tag);
  return $self->recv_createTag();
}

sub send_createTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

  $self->{output}->writeMessageBegin('createTag', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{tag} = $tag;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createTag{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "createTag failed: unknown result";
}
sub updateTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

    $self->send_updateTag($authenticationToken, $tag);
  return $self->recv_updateTag();
}

sub send_updateTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $tag = shift;

  $self->{output}->writeMessageBegin('updateTag', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{tag} = $tag;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateTag{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "updateTag failed: unknown result";
}
sub untagAll{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_untagAll($authenticationToken, $guid);
  $self->recv_untagAll();
}

sub send_untagAll{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('untagAll', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_untagAll{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  return;
}
sub expungeTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_expungeTag($authenticationToken, $guid);
  return $self->recv_expungeTag();
}

sub send_expungeTag{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('expungeTag', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeTag{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "expungeTag failed: unknown result";
}
sub listSearches{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_listSearches($authenticationToken);
  return $self->recv_listSearches();
}

sub send_listSearches{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('listSearches', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listSearches{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "listSearches failed: unknown result";
}
sub getSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getSearch($authenticationToken, $guid);
  return $self->recv_getSearch();
}

sub send_getSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getSearch', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getSearch{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getSearch failed: unknown result";
}
sub createSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

    $self->send_createSearch($authenticationToken, $search);
  return $self->recv_createSearch();
}

sub send_createSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

  $self->{output}->writeMessageBegin('createSearch', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{search} = $search;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createSearch{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "createSearch failed: unknown result";
}
sub updateSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

    $self->send_updateSearch($authenticationToken, $search);
  return $self->recv_updateSearch();
}

sub send_updateSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $search = shift;

  $self->{output}->writeMessageBegin('updateSearch', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{search} = $search;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateSearch{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "updateSearch failed: unknown result";
}
sub expungeSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_expungeSearch($authenticationToken, $guid);
  return $self->recv_expungeSearch();
}

sub send_expungeSearch{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('expungeSearch', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeSearch{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "expungeSearch failed: unknown result";
}
sub findNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;

    $self->send_findNotes($authenticationToken, $filter, $offset, $maxNotes);
  return $self->recv_findNotes();
}

sub send_findNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;

  $self->{output}->writeMessageBegin('findNotes', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{filter} = $filter;
  $args->{offset} = $offset;
  $args->{maxNotes} = $maxNotes;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_findNotes{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "findNotes failed: unknown result";
}
sub findNoteOffset{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $guid = shift;

    $self->send_findNoteOffset($authenticationToken, $filter, $guid);
  return $self->recv_findNoteOffset();
}

sub send_findNoteOffset{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('findNoteOffset', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{filter} = $filter;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_findNoteOffset{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "findNoteOffset failed: unknown result";
}
sub findNotesMetadata{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;
  my $resultSpec = shift;

    $self->send_findNotesMetadata($authenticationToken, $filter, $offset, $maxNotes, $resultSpec);
  return $self->recv_findNotesMetadata();
}

sub send_findNotesMetadata{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $offset = shift;
  my $maxNotes = shift;
  my $resultSpec = shift;

  $self->{output}->writeMessageBegin('findNotesMetadata', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{filter} = $filter;
  $args->{offset} = $offset;
  $args->{maxNotes} = $maxNotes;
  $args->{resultSpec} = $resultSpec;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_findNotesMetadata{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "findNotesMetadata failed: unknown result";
}
sub findNoteCounts{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $withTrash = shift;

    $self->send_findNoteCounts($authenticationToken, $filter, $withTrash);
  return $self->recv_findNoteCounts();
}

sub send_findNoteCounts{
  my $self = shift;
  my $authenticationToken = shift;
  my $filter = shift;
  my $withTrash = shift;

  $self->{output}->writeMessageBegin('findNoteCounts', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{filter} = $filter;
  $args->{withTrash} = $withTrash;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_findNoteCounts{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "findNoteCounts failed: unknown result";
}
sub getNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withContent = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

    $self->send_getNote($authenticationToken, $guid, $withContent, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
  return $self->recv_getNote();
}

sub send_getNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withContent = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

  $self->{output}->writeMessageBegin('getNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{withContent} = $withContent;
  $args->{withResourcesData} = $withResourcesData;
  $args->{withResourcesRecognition} = $withResourcesRecognition;
  $args->{withResourcesAlternateData} = $withResourcesAlternateData;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNote failed: unknown result";
}
sub getNoteApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getNoteApplicationData($authenticationToken, $guid);
  return $self->recv_getNoteApplicationData();
}

sub send_getNoteApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getNoteApplicationData', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteApplicationData{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteApplicationData failed: unknown result";
}
sub getNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

    $self->send_getNoteApplicationDataEntry($authenticationToken, $guid, $key);
  return $self->recv_getNoteApplicationDataEntry();
}

sub send_getNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  $self->{output}->writeMessageBegin('getNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteApplicationDataEntry failed: unknown result";
}
sub setNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

    $self->send_setNoteApplicationDataEntry($authenticationToken, $guid, $key, $value);
  return $self->recv_setNoteApplicationDataEntry();
}

sub send_setNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

  $self->{output}->writeMessageBegin('setNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->{value} = $value;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_setNoteApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "setNoteApplicationDataEntry failed: unknown result";
}
sub unsetNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

    $self->send_unsetNoteApplicationDataEntry($authenticationToken, $guid, $key);
  return $self->recv_unsetNoteApplicationDataEntry();
}

sub send_unsetNoteApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  $self->{output}->writeMessageBegin('unsetNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_unsetNoteApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "unsetNoteApplicationDataEntry failed: unknown result";
}
sub getNoteContent{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getNoteContent($authenticationToken, $guid);
  return $self->recv_getNoteContent();
}

sub send_getNoteContent{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getNoteContent', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteContent{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteContent failed: unknown result";
}
sub getNoteSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $noteOnly = shift;
  my $tokenizeForIndexing = shift;

    $self->send_getNoteSearchText($authenticationToken, $guid, $noteOnly, $tokenizeForIndexing);
  return $self->recv_getNoteSearchText();
}

sub send_getNoteSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $noteOnly = shift;
  my $tokenizeForIndexing = shift;

  $self->{output}->writeMessageBegin('getNoteSearchText', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{noteOnly} = $noteOnly;
  $args->{tokenizeForIndexing} = $tokenizeForIndexing;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteSearchText{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteSearchText failed: unknown result";
}
sub getResourceSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceSearchText($authenticationToken, $guid);
  return $self->recv_getResourceSearchText();
}

sub send_getResourceSearchText{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceSearchText', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceSearchText{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceSearchText failed: unknown result";
}
sub getNoteTagNames{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getNoteTagNames($authenticationToken, $guid);
  return $self->recv_getNoteTagNames();
}

sub send_getNoteTagNames{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getNoteTagNames', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteTagNames{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteTagNames failed: unknown result";
}
sub createNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

    $self->send_createNote($authenticationToken, $note);
  return $self->recv_createNote();
}

sub send_createNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

  $self->{output}->writeMessageBegin('createNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{note} = $note;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "createNote failed: unknown result";
}
sub updateNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

    $self->send_updateNote($authenticationToken, $note);
  return $self->recv_updateNote();
}

sub send_updateNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $note = shift;

  $self->{output}->writeMessageBegin('updateNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{note} = $note;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "updateNote failed: unknown result";
}
sub deleteNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_deleteNote($authenticationToken, $guid);
  return $self->recv_deleteNote();
}

sub send_deleteNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('deleteNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_deleteNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "deleteNote failed: unknown result";
}
sub expungeNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_expungeNote($authenticationToken, $guid);
  return $self->recv_expungeNote();
}

sub send_expungeNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('expungeNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "expungeNote failed: unknown result";
}
sub expungeNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuids = shift;

    $self->send_expungeNotes($authenticationToken, $noteGuids);
  return $self->recv_expungeNotes();
}

sub send_expungeNotes{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuids = shift;

  $self->{output}->writeMessageBegin('expungeNotes', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{noteGuids} = $noteGuids;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeNotes{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "expungeNotes failed: unknown result";
}
sub expungeInactiveNotes{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_expungeInactiveNotes($authenticationToken);
  return $self->recv_expungeInactiveNotes();
}

sub send_expungeInactiveNotes{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('expungeInactiveNotes', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeInactiveNotes{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "expungeInactiveNotes failed: unknown result";
}
sub copyNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $toNotebookGuid = shift;

    $self->send_copyNote($authenticationToken, $noteGuid, $toNotebookGuid);
  return $self->recv_copyNote();
}

sub send_copyNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $toNotebookGuid = shift;

  $self->{output}->writeMessageBegin('copyNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{noteGuid} = $noteGuid;
  $args->{toNotebookGuid} = $toNotebookGuid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_copyNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "copyNote failed: unknown result";
}
sub listNoteVersions{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;

    $self->send_listNoteVersions($authenticationToken, $noteGuid);
  return $self->recv_listNoteVersions();
}

sub send_listNoteVersions{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;

  $self->{output}->writeMessageBegin('listNoteVersions', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{noteGuid} = $noteGuid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listNoteVersions{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "listNoteVersions failed: unknown result";
}
sub getNoteVersion{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $updateSequenceNum = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

    $self->send_getNoteVersion($authenticationToken, $noteGuid, $updateSequenceNum, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
  return $self->recv_getNoteVersion();
}

sub send_getNoteVersion{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $updateSequenceNum = shift;
  my $withResourcesData = shift;
  my $withResourcesRecognition = shift;
  my $withResourcesAlternateData = shift;

  $self->{output}->writeMessageBegin('getNoteVersion', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{noteGuid} = $noteGuid;
  $args->{updateSequenceNum} = $updateSequenceNum;
  $args->{withResourcesData} = $withResourcesData;
  $args->{withResourcesRecognition} = $withResourcesRecognition;
  $args->{withResourcesAlternateData} = $withResourcesAlternateData;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteVersion{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getNoteVersion failed: unknown result";
}
sub getResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAttributes = shift;
  my $withAlternateData = shift;

    $self->send_getResource($authenticationToken, $guid, $withData, $withRecognition, $withAttributes, $withAlternateData);
  return $self->recv_getResource();
}

sub send_getResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAttributes = shift;
  my $withAlternateData = shift;

  $self->{output}->writeMessageBegin('getResource', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{withData} = $withData;
  $args->{withRecognition} = $withRecognition;
  $args->{withAttributes} = $withAttributes;
  $args->{withAlternateData} = $withAlternateData;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResource{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResource failed: unknown result";
}
sub getResourceApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceApplicationData($authenticationToken, $guid);
  return $self->recv_getResourceApplicationData();
}

sub send_getResourceApplicationData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceApplicationData', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceApplicationData{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceApplicationData failed: unknown result";
}
sub getResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

    $self->send_getResourceApplicationDataEntry($authenticationToken, $guid, $key);
  return $self->recv_getResourceApplicationDataEntry();
}

sub send_getResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  $self->{output}->writeMessageBegin('getResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceApplicationDataEntry failed: unknown result";
}
sub setResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

    $self->send_setResourceApplicationDataEntry($authenticationToken, $guid, $key, $value);
  return $self->recv_setResourceApplicationDataEntry();
}

sub send_setResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;
  my $value = shift;

  $self->{output}->writeMessageBegin('setResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->{value} = $value;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_setResourceApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "setResourceApplicationDataEntry failed: unknown result";
}
sub unsetResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

    $self->send_unsetResourceApplicationDataEntry($authenticationToken, $guid, $key);
  return $self->recv_unsetResourceApplicationDataEntry();
}

sub send_unsetResourceApplicationDataEntry{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;
  my $key = shift;

  $self->{output}->writeMessageBegin('unsetResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->{key} = $key;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_unsetResourceApplicationDataEntry{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "unsetResourceApplicationDataEntry failed: unknown result";
}
sub updateResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $resource = shift;

    $self->send_updateResource($authenticationToken, $resource);
  return $self->recv_updateResource();
}

sub send_updateResource{
  my $self = shift;
  my $authenticationToken = shift;
  my $resource = shift;

  $self->{output}->writeMessageBegin('updateResource', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{resource} = $resource;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateResource{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "updateResource failed: unknown result";
}
sub getResourceData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceData($authenticationToken, $guid);
  return $self->recv_getResourceData();
}

sub send_getResourceData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceData', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceData{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceData failed: unknown result";
}
sub getResourceByHash{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $contentHash = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAlternateData = shift;

    $self->send_getResourceByHash($authenticationToken, $noteGuid, $contentHash, $withData, $withRecognition, $withAlternateData);
  return $self->recv_getResourceByHash();
}

sub send_getResourceByHash{
  my $self = shift;
  my $authenticationToken = shift;
  my $noteGuid = shift;
  my $contentHash = shift;
  my $withData = shift;
  my $withRecognition = shift;
  my $withAlternateData = shift;

  $self->{output}->writeMessageBegin('getResourceByHash', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{noteGuid} = $noteGuid;
  $args->{contentHash} = $contentHash;
  $args->{withData} = $withData;
  $args->{withRecognition} = $withRecognition;
  $args->{withAlternateData} = $withAlternateData;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceByHash{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceByHash failed: unknown result";
}
sub getResourceRecognition{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceRecognition($authenticationToken, $guid);
  return $self->recv_getResourceRecognition();
}

sub send_getResourceRecognition{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceRecognition', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceRecognition{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceRecognition failed: unknown result";
}
sub getResourceAlternateData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceAlternateData($authenticationToken, $guid);
  return $self->recv_getResourceAlternateData();
}

sub send_getResourceAlternateData{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceAlternateData', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceAlternateData{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceAlternateData failed: unknown result";
}
sub getResourceAttributes{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_getResourceAttributes($authenticationToken, $guid);
  return $self->recv_getResourceAttributes();
}

sub send_getResourceAttributes{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('getResourceAttributes', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getResourceAttributes{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getResourceAttributes failed: unknown result";
}
sub getAccountSize{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getAccountSize($authenticationToken);
  return $self->recv_getAccountSize();
}

sub send_getAccountSize{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getAccountSize', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getAccountSize{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getAccountSize failed: unknown result";
}
sub getAds{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

    $self->send_getAds($authenticationToken, $adParameters);
  return $self->recv_getAds();
}

sub send_getAds{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

  $self->{output}->writeMessageBegin('getAds', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{adParameters} = $adParameters;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getAds{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getAds failed: unknown result";
}
sub getRandomAd{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

    $self->send_getRandomAd($authenticationToken, $adParameters);
  return $self->recv_getRandomAd();
}

sub send_getRandomAd{
  my $self = shift;
  my $authenticationToken = shift;
  my $adParameters = shift;

  $self->{output}->writeMessageBegin('getRandomAd', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{adParameters} = $adParameters;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getRandomAd{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getRandomAd failed: unknown result";
}
sub getPublicNotebook{
  my $self = shift;
  my $userId = shift;
  my $publicUri = shift;

    $self->send_getPublicNotebook($userId, $publicUri);
  return $self->recv_getPublicNotebook();
}

sub send_getPublicNotebook{
  my $self = shift;
  my $userId = shift;
  my $publicUri = shift;

  $self->{output}->writeMessageBegin('getPublicNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->new();
  $args->{userId} = $userId;
  $args->{publicUri} = $publicUri;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getPublicNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  die "getPublicNotebook failed: unknown result";
}
sub createSharedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebook = shift;

    $self->send_createSharedNotebook($authenticationToken, $sharedNotebook);
  return $self->recv_createSharedNotebook();
}

sub send_createSharedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebook = shift;

  $self->{output}->writeMessageBegin('createSharedNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{sharedNotebook} = $sharedNotebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createSharedNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "createSharedNotebook failed: unknown result";
}
sub sendMessageToSharedNotebookMembers{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;
  my $messageText = shift;
  my $recipients = shift;

    $self->send_sendMessageToSharedNotebookMembers($authenticationToken, $notebookGuid, $messageText, $recipients);
  return $self->recv_sendMessageToSharedNotebookMembers();
}

sub send_sendMessageToSharedNotebookMembers{
  my $self = shift;
  my $authenticationToken = shift;
  my $notebookGuid = shift;
  my $messageText = shift;
  my $recipients = shift;

  $self->{output}->writeMessageBegin('sendMessageToSharedNotebookMembers', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{notebookGuid} = $notebookGuid;
  $args->{messageText} = $messageText;
  $args->{recipients} = $recipients;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_sendMessageToSharedNotebookMembers{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "sendMessageToSharedNotebookMembers failed: unknown result";
}
sub listSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_listSharedNotebooks($authenticationToken);
  return $self->recv_listSharedNotebooks();
}

sub send_listSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('listSharedNotebooks', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listSharedNotebooks{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "listSharedNotebooks failed: unknown result";
}
sub expungeSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebookIds = shift;

    $self->send_expungeSharedNotebooks($authenticationToken, $sharedNotebookIds);
  return $self->recv_expungeSharedNotebooks();
}

sub send_expungeSharedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;
  my $sharedNotebookIds = shift;

  $self->{output}->writeMessageBegin('expungeSharedNotebooks', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{sharedNotebookIds} = $sharedNotebookIds;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeSharedNotebooks{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "expungeSharedNotebooks failed: unknown result";
}
sub createLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

    $self->send_createLinkedNotebook($authenticationToken, $linkedNotebook);
  return $self->recv_createLinkedNotebook();
}

sub send_createLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  $self->{output}->writeMessageBegin('createLinkedNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{linkedNotebook} = $linkedNotebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_createLinkedNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "createLinkedNotebook failed: unknown result";
}
sub updateLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

    $self->send_updateLinkedNotebook($authenticationToken, $linkedNotebook);
  return $self->recv_updateLinkedNotebook();
}

sub send_updateLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $linkedNotebook = shift;

  $self->{output}->writeMessageBegin('updateLinkedNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{linkedNotebook} = $linkedNotebook;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_updateLinkedNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "updateLinkedNotebook failed: unknown result";
}
sub listLinkedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_listLinkedNotebooks($authenticationToken);
  return $self->recv_listLinkedNotebooks();
}

sub send_listLinkedNotebooks{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('listLinkedNotebooks', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_listLinkedNotebooks{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "listLinkedNotebooks failed: unknown result";
}
sub expungeLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_expungeLinkedNotebook($authenticationToken, $guid);
  return $self->recv_expungeLinkedNotebook();
}

sub send_expungeLinkedNotebook{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('expungeLinkedNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_expungeLinkedNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "expungeLinkedNotebook failed: unknown result";
}
sub authenticateToSharedNotebook{
  my $self = shift;
  my $shareKey = shift;
  my $authenticationToken = shift;

    $self->send_authenticateToSharedNotebook($shareKey, $authenticationToken);
  return $self->recv_authenticateToSharedNotebook();
}

sub send_authenticateToSharedNotebook{
  my $self = shift;
  my $shareKey = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('authenticateToSharedNotebook', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->new();
  $args->{shareKey} = $shareKey;
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_authenticateToSharedNotebook{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "authenticateToSharedNotebook failed: unknown result";
}
sub getSharedNotebookByAuth{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getSharedNotebookByAuth($authenticationToken);
  return $self->recv_getSharedNotebookByAuth();
}

sub send_getSharedNotebookByAuth{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getSharedNotebookByAuth', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getSharedNotebookByAuth{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getSharedNotebookByAuth failed: unknown result";
}
sub emailNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $parameters = shift;

    $self->send_emailNote($authenticationToken, $parameters);
  $self->recv_emailNote();
}

sub send_emailNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $parameters = shift;

  $self->{output}->writeMessageBegin('emailNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{parameters} = $parameters;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_emailNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  return;
}
sub shareNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_shareNote($authenticationToken, $guid);
  return $self->recv_shareNote();
}

sub send_shareNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('shareNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_shareNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "shareNote failed: unknown result";
}
sub stopSharingNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

    $self->send_stopSharingNote($authenticationToken, $guid);
  $self->recv_stopSharingNote();
}

sub send_stopSharingNote{
  my $self = shift;
  my $authenticationToken = shift;
  my $guid = shift;

  $self->{output}->writeMessageBegin('stopSharingNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->{guid} = $guid;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_stopSharingNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  return;
}
sub authenticateToSharedNote{
  my $self = shift;
  my $guid = shift;
  my $noteKey = shift;

    $self->send_authenticateToSharedNote($guid, $noteKey);
  return $self->recv_authenticateToSharedNote();
}

sub send_authenticateToSharedNote{
  my $self = shift;
  my $guid = shift;
  my $noteKey = shift;

  $self->{output}->writeMessageBegin('authenticateToSharedNote', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->new();
  $args->{guid} = $guid;
  $args->{noteKey} = $noteKey;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_authenticateToSharedNote{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "authenticateToSharedNote failed: unknown result";
}
package Net::Evernote::EDAMNoteStore::NoteStoreProcessor;

use strict;


sub new {
    my ($classname, $handler) = @_;
    my $self      = {};
    $self->{handler} = $handler;
    return bless ($self, $classname);
}

sub process {
    my ($self, $input, $output) = @_;
    my $rseqid = 0;
    my $fname  = undef;
    my $mtype  = 0;

    $input->readMessageBegin(\$fname, \$mtype, \$rseqid);
    my $methodname = 'process_'.$fname;
    if (!$self->can($methodname)) {
      $input->skip(TType::STRUCT);
      $input->readMessageEnd();
      my $x = TApplicationException->new('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
      $output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
      $x->write($output);
      $output->writeMessageEnd();
      $output->getTransport()->flush();
      return;
    }
    $self->$methodname($rseqid, $input, $output);
    return 1;
}

sub process_getSyncState {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->new();
    eval {
      $result->{success} = $self->{handler}->getSyncState($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getSyncState', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getSyncChunk {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->new();
    eval {
      $result->{success} = $self->{handler}->getSyncChunk($args->authenticationToken, $args->afterUSN, $args->maxEntries, $args->fullSyncOnly);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getSyncChunk', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getFilteredSyncChunk {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->new();
    eval {
      $result->{success} = $self->{handler}->getFilteredSyncChunk($args->authenticationToken, $args->afterUSN, $args->maxEntries, $args->filter);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getFilteredSyncChunk', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getLinkedNotebookSyncState {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->new();
    eval {
      $result->{success} = $self->{handler}->getLinkedNotebookSyncState($args->authenticationToken, $args->linkedNotebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getLinkedNotebookSyncState', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getLinkedNotebookSyncChunk {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->new();
    eval {
      $result->{success} = $self->{handler}->getLinkedNotebookSyncChunk($args->authenticationToken, $args->linkedNotebook, $args->afterUSN, $args->maxEntries, $args->fullSyncOnly);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getLinkedNotebookSyncChunk', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listNotebooks {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->new();
    eval {
      $result->{success} = $self->{handler}->listNotebooks($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('listNotebooks', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->getNotebook($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getDefaultNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->getDefaultNotebook($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getDefaultNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->createNotebook($args->authenticationToken, $args->notebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('createNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->updateNotebook($args->authenticationToken, $args->notebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('updateNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeNotebook($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('expungeNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listTags {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->new();
    eval {
      $result->{success} = $self->{handler}->listTags($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('listTags', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listTagsByNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->listTagsByNotebook($args->authenticationToken, $args->notebookGuid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('listTagsByNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getTag {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->new();
    eval {
      $result->{success} = $self->{handler}->getTag($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getTag', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createTag {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->new();
    eval {
      $result->{success} = $self->{handler}->createTag($args->authenticationToken, $args->tag);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('createTag', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateTag {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->new();
    eval {
      $result->{success} = $self->{handler}->updateTag($args->authenticationToken, $args->tag);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('updateTag', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_untagAll {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->new();
    eval {
      $self->{handler}->untagAll($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('untagAll', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeTag {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeTag($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('expungeTag', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listSearches {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->new();
    eval {
      $result->{success} = $self->{handler}->listSearches($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('listSearches', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getSearch {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->new();
    eval {
      $result->{success} = $self->{handler}->getSearch($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getSearch', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createSearch {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->new();
    eval {
      $result->{success} = $self->{handler}->createSearch($args->authenticationToken, $args->search);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('createSearch', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateSearch {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->new();
    eval {
      $result->{success} = $self->{handler}->updateSearch($args->authenticationToken, $args->search);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('updateSearch', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeSearch {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeSearch($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('expungeSearch', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_findNotes {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->new();
    eval {
      $result->{success} = $self->{handler}->findNotes($args->authenticationToken, $args->filter, $args->offset, $args->maxNotes);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('findNotes', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_findNoteOffset {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->new();
    eval {
      $result->{success} = $self->{handler}->findNoteOffset($args->authenticationToken, $args->filter, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('findNoteOffset', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_findNotesMetadata {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->new();
    eval {
      $result->{success} = $self->{handler}->findNotesMetadata($args->authenticationToken, $args->filter, $args->offset, $args->maxNotes, $args->resultSpec);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('findNotesMetadata', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_findNoteCounts {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->new();
    eval {
      $result->{success} = $self->{handler}->findNoteCounts($args->authenticationToken, $args->filter, $args->withTrash);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('findNoteCounts', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->new();
    eval {
      $result->{success} = $self->{handler}->getNote($args->authenticationToken, $args->guid, $args->withContent, $args->withResourcesData, $args->withResourcesRecognition, $args->withResourcesAlternateData);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteApplicationData {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteApplicationData($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteApplicationData', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_setNoteApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->setNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key, $args->value);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('setNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_unsetNoteApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->unsetNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('unsetNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteContent {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteContent($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteContent', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteSearchText {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteSearchText($args->authenticationToken, $args->guid, $args->noteOnly, $args->tokenizeForIndexing);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteSearchText', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceSearchText {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceSearchText($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceSearchText', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteTagNames {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteTagNames($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteTagNames', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->new();
    eval {
      $result->{success} = $self->{handler}->createNote($args->authenticationToken, $args->note);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('createNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->new();
    eval {
      $result->{success} = $self->{handler}->updateNote($args->authenticationToken, $args->note);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('updateNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_deleteNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->new();
    eval {
      $result->{success} = $self->{handler}->deleteNote($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('deleteNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeNote($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('expungeNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeNotes {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeNotes($args->authenticationToken, $args->noteGuids);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('expungeNotes', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeInactiveNotes {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeInactiveNotes($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('expungeInactiveNotes', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_copyNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->new();
    eval {
      $result->{success} = $self->{handler}->copyNote($args->authenticationToken, $args->noteGuid, $args->toNotebookGuid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('copyNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listNoteVersions {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->new();
    eval {
      $result->{success} = $self->{handler}->listNoteVersions($args->authenticationToken, $args->noteGuid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('listNoteVersions', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteVersion {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteVersion($args->authenticationToken, $args->noteGuid, $args->updateSequenceNum, $args->withResourcesData, $args->withResourcesRecognition, $args->withResourcesAlternateData);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getNoteVersion', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResource {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->new();
    eval {
      $result->{success} = $self->{handler}->getResource($args->authenticationToken, $args->guid, $args->withData, $args->withRecognition, $args->withAttributes, $args->withAlternateData);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResource', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceApplicationData {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceApplicationData($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceApplicationData', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_setResourceApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->setResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key, $args->value);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('setResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_unsetResourceApplicationDataEntry {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->new();
    eval {
      $result->{success} = $self->{handler}->unsetResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('unsetResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateResource {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->new();
    eval {
      $result->{success} = $self->{handler}->updateResource($args->authenticationToken, $args->resource);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('updateResource', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceData {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceData($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceData', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceByHash {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceByHash($args->authenticationToken, $args->noteGuid, $args->contentHash, $args->withData, $args->withRecognition, $args->withAlternateData);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceByHash', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceRecognition {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceRecognition($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceRecognition', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceAlternateData {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceAlternateData($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceAlternateData', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getResourceAttributes {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->new();
    eval {
      $result->{success} = $self->{handler}->getResourceAttributes($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getResourceAttributes', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getAccountSize {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->new();
    eval {
      $result->{success} = $self->{handler}->getAccountSize($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getAccountSize', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getAds {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->new();
    eval {
      $result->{success} = $self->{handler}->getAds($args->authenticationToken, $args->adParameters);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getAds', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getRandomAd {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->new();
    eval {
      $result->{success} = $self->{handler}->getRandomAd($args->authenticationToken, $args->adParameters);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getRandomAd', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getPublicNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->getPublicNotebook($args->userId, $args->publicUri);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
    }
    $output->writeMessageBegin('getPublicNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createSharedNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->createSharedNotebook($args->authenticationToken, $args->sharedNotebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('createSharedNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_sendMessageToSharedNotebookMembers {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->new();
    eval {
      $result->{success} = $self->{handler}->sendMessageToSharedNotebookMembers($args->authenticationToken, $args->notebookGuid, $args->messageText, $args->recipients);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('sendMessageToSharedNotebookMembers', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listSharedNotebooks {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->new();
    eval {
      $result->{success} = $self->{handler}->listSharedNotebooks($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('listSharedNotebooks', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeSharedNotebooks {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeSharedNotebooks($args->authenticationToken, $args->sharedNotebookIds);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('expungeSharedNotebooks', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_createLinkedNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->createLinkedNotebook($args->authenticationToken, $args->linkedNotebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('createLinkedNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_updateLinkedNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->updateLinkedNotebook($args->authenticationToken, $args->linkedNotebook);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('updateLinkedNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_listLinkedNotebooks {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->new();
    eval {
      $result->{success} = $self->{handler}->listLinkedNotebooks($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('listLinkedNotebooks', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_expungeLinkedNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->expungeLinkedNotebook($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('expungeLinkedNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_authenticateToSharedNotebook {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->new();
    eval {
      $result->{success} = $self->{handler}->authenticateToSharedNotebook($args->shareKey, $args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('authenticateToSharedNotebook', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getSharedNotebookByAuth {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->new();
    eval {
      $result->{success} = $self->{handler}->getSharedNotebookByAuth($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getSharedNotebookByAuth', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_emailNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->new();
    eval {
      $self->{handler}->emailNote($args->authenticationToken, $args->parameters);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('emailNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_shareNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->new();
    eval {
      $result->{success} = $self->{handler}->shareNote($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('shareNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_stopSharingNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->new();
    eval {
      $self->{handler}->stopSharingNote($args->authenticationToken, $args->guid);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('stopSharingNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_authenticateToSharedNote {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->new();
    eval {
      $result->{success} = $self->{handler}->authenticateToSharedNote($args->guid, $args->noteKey);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('authenticateToSharedNote', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

1;

lib/Net/Evernote/EDAMNoteStore/Types.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

package Net::Evernote::EDAMNoteStore::SyncState;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::SyncState->mk_accessors( qw( currentTime fullSyncBefore updateCount uploaded ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{currentTime} = undef;
  $self->{fullSyncBefore} = undef;
  $self->{updateCount} = undef;
  $self->{uploaded} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{currentTime}) {
      $self->{currentTime} = $vals->{currentTime};
    }
    if (defined $vals->{fullSyncBefore}) {
      $self->{fullSyncBefore} = $vals->{fullSyncBefore};
    }
    if (defined $vals->{updateCount}) {
      $self->{updateCount} = $vals->{updateCount};
    }
    if (defined $vals->{uploaded}) {
      $self->{uploaded} = $vals->{uploaded};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'SyncState';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{currentTime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{fullSyncBefore});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{uploaded});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('SyncState');
  if (defined $self->{currentTime}) {
    $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
    $xfer += $output->writeI64($self->{currentTime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{fullSyncBefore}) {
    $xfer += $output->writeFieldBegin('fullSyncBefore', TType::I64, 2);
    $xfer += $output->writeI64($self->{fullSyncBefore});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateCount}) {
    $xfer += $output->writeFieldBegin('updateCount', TType::I32, 3);
    $xfer += $output->writeI32($self->{updateCount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{uploaded}) {
    $xfer += $output->writeFieldBegin('uploaded', TType::I64, 4);
    $xfer += $output->writeI64($self->{uploaded});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::SyncChunk;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::SyncChunk->mk_accessors( qw( currentTime chunkHighUSN updateCount notes notebooks tags searches resources expungedNotes expungedNotebooks expungedTags expungedSearches linkedNotebooks expungedLinkedNotebooks ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{currentTime} = undef;
  $self->{chunkHighUSN} = undef;
  $self->{updateCount} = undef;
  $self->{notes} = undef;
  $self->{notebooks} = undef;
  $self->{tags} = undef;
  $self->{searches} = undef;
  $self->{resources} = undef;
  $self->{expungedNotes} = undef;
  $self->{expungedNotebooks} = undef;
  $self->{expungedTags} = undef;
  $self->{expungedSearches} = undef;
  $self->{linkedNotebooks} = undef;
  $self->{expungedLinkedNotebooks} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{currentTime}) {
      $self->{currentTime} = $vals->{currentTime};
    }
    if (defined $vals->{chunkHighUSN}) {
      $self->{chunkHighUSN} = $vals->{chunkHighUSN};
    }
    if (defined $vals->{updateCount}) {
      $self->{updateCount} = $vals->{updateCount};
    }
    if (defined $vals->{notes}) {
      $self->{notes} = $vals->{notes};
    }
    if (defined $vals->{notebooks}) {
      $self->{notebooks} = $vals->{notebooks};
    }
    if (defined $vals->{tags}) {
      $self->{tags} = $vals->{tags};
    }
    if (defined $vals->{searches}) {
      $self->{searches} = $vals->{searches};
    }
    if (defined $vals->{resources}) {
      $self->{resources} = $vals->{resources};
    }
    if (defined $vals->{expungedNotes}) {
      $self->{expungedNotes} = $vals->{expungedNotes};
    }
    if (defined $vals->{expungedNotebooks}) {
      $self->{expungedNotebooks} = $vals->{expungedNotebooks};
    }
    if (defined $vals->{expungedTags}) {
      $self->{expungedTags} = $vals->{expungedTags};
    }
    if (defined $vals->{expungedSearches}) {
      $self->{expungedSearches} = $vals->{expungedSearches};
    }
    if (defined $vals->{linkedNotebooks}) {
      $self->{linkedNotebooks} = $vals->{linkedNotebooks};
    }
    if (defined $vals->{expungedLinkedNotebooks}) {
      $self->{expungedLinkedNotebooks} = $vals->{expungedLinkedNotebooks};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'SyncChunk';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{currentTime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{chunkHighUSN});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size0 = 0;
          $self->{notes} = [];
          my $_etype3 = 0;
          $xfer += $input->readListBegin(\$_etype3, \$_size0);
          for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
          {
            my $elem5 = undef;
            $elem5 = Net::Evernote::EDAMTypes::Note->new();
            $xfer += $elem5->read($input);
            push(@{$self->{notes}},$elem5);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size6 = 0;
          $self->{notebooks} = [];
          my $_etype9 = 0;
          $xfer += $input->readListBegin(\$_etype9, \$_size6);
          for (my $_i10 = 0; $_i10 < $_size6; ++$_i10)
          {
            my $elem11 = undef;
            $elem11 = Net::Evernote::EDAMTypes::Notebook->new();
            $xfer += $elem11->read($input);
            push(@{$self->{notebooks}},$elem11);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size12 = 0;
          $self->{tags} = [];
          my $_etype15 = 0;
          $xfer += $input->readListBegin(\$_etype15, \$_size12);
          for (my $_i16 = 0; $_i16 < $_size12; ++$_i16)
          {
            my $elem17 = undef;
            $elem17 = Net::Evernote::EDAMTypes::Tag->new();
            $xfer += $elem17->read($input);
            push(@{$self->{tags}},$elem17);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size18 = 0;
          $self->{searches} = [];
          my $_etype21 = 0;
          $xfer += $input->readListBegin(\$_etype21, \$_size18);
          for (my $_i22 = 0; $_i22 < $_size18; ++$_i22)
          {
            my $elem23 = undef;
            $elem23 = Net::Evernote::EDAMTypes::SavedSearch->new();
            $xfer += $elem23->read($input);
            push(@{$self->{searches}},$elem23);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size24 = 0;
          $self->{resources} = [];
          my $_etype27 = 0;
          $xfer += $input->readListBegin(\$_etype27, \$_size24);
          for (my $_i28 = 0; $_i28 < $_size24; ++$_i28)
          {
            my $elem29 = undef;
            $elem29 = Net::Evernote::EDAMTypes::Resource->new();
            $xfer += $elem29->read($input);
            push(@{$self->{resources}},$elem29);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size30 = 0;
          $self->{expungedNotes} = [];
          my $_etype33 = 0;
          $xfer += $input->readListBegin(\$_etype33, \$_size30);
          for (my $_i34 = 0; $_i34 < $_size30; ++$_i34)
          {
            my $elem35 = undef;
            $xfer += $input->readString(\$elem35);
            push(@{$self->{expungedNotes}},$elem35);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size36 = 0;
          $self->{expungedNotebooks} = [];
          my $_etype39 = 0;
          $xfer += $input->readListBegin(\$_etype39, \$_size36);
          for (my $_i40 = 0; $_i40 < $_size36; ++$_i40)
          {
            my $elem41 = undef;
            $xfer += $input->readString(\$elem41);
            push(@{$self->{expungedNotebooks}},$elem41);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size42 = 0;
          $self->{expungedTags} = [];
          my $_etype45 = 0;
          $xfer += $input->readListBegin(\$_etype45, \$_size42);
          for (my $_i46 = 0; $_i46 < $_size42; ++$_i46)
          {
            my $elem47 = undef;
            $xfer += $input->readString(\$elem47);
            push(@{$self->{expungedTags}},$elem47);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size48 = 0;
          $self->{expungedSearches} = [];
          my $_etype51 = 0;
          $xfer += $input->readListBegin(\$_etype51, \$_size48);
          for (my $_i52 = 0; $_i52 < $_size48; ++$_i52)
          {
            my $elem53 = undef;
            $xfer += $input->readString(\$elem53);
            push(@{$self->{expungedSearches}},$elem53);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size54 = 0;
          $self->{linkedNotebooks} = [];
          my $_etype57 = 0;
          $xfer += $input->readListBegin(\$_etype57, \$_size54);
          for (my $_i58 = 0; $_i58 < $_size54; ++$_i58)
          {
            my $elem59 = undef;
            $elem59 = Net::Evernote::EDAMTypes::LinkedNotebook->new();
            $xfer += $elem59->read($input);
            push(@{$self->{linkedNotebooks}},$elem59);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size60 = 0;
          $self->{expungedLinkedNotebooks} = [];
          my $_etype63 = 0;
          $xfer += $input->readListBegin(\$_etype63, \$_size60);
          for (my $_i64 = 0; $_i64 < $_size60; ++$_i64)
          {
            my $elem65 = undef;
            $xfer += $input->readString(\$elem65);
            push(@{$self->{expungedLinkedNotebooks}},$elem65);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('SyncChunk');
  if (defined $self->{currentTime}) {
    $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
    $xfer += $output->writeI64($self->{currentTime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{chunkHighUSN}) {
    $xfer += $output->writeFieldBegin('chunkHighUSN', TType::I32, 2);
    $xfer += $output->writeI32($self->{chunkHighUSN});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateCount}) {
    $xfer += $output->writeFieldBegin('updateCount', TType::I32, 3);
    $xfer += $output->writeI32($self->{updateCount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notes}) {
    $xfer += $output->writeFieldBegin('notes', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
      {
        foreach my $iter66 (@{$self->{notes}}) 
        {
          $xfer += ${iter66}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebooks}) {
    $xfer += $output->writeFieldBegin('notebooks', TType::LIST, 5);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notebooks}}));
      {
        foreach my $iter67 (@{$self->{notebooks}}) 
        {
          $xfer += ${iter67}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tags}) {
    $xfer += $output->writeFieldBegin('tags', TType::LIST, 6);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{tags}}));
      {
        foreach my $iter68 (@{$self->{tags}}) 
        {
          $xfer += ${iter68}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{searches}) {
    $xfer += $output->writeFieldBegin('searches', TType::LIST, 7);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{searches}}));
      {
        foreach my $iter69 (@{$self->{searches}}) 
        {
          $xfer += ${iter69}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{resources}) {
    $xfer += $output->writeFieldBegin('resources', TType::LIST, 8);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{resources}}));
      {
        foreach my $iter70 (@{$self->{resources}}) 
        {
          $xfer += ${iter70}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expungedNotes}) {
    $xfer += $output->writeFieldBegin('expungedNotes', TType::LIST, 9);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedNotes}}));
      {
        foreach my $iter71 (@{$self->{expungedNotes}}) 
        {
          $xfer += $output->writeString($iter71);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expungedNotebooks}) {
    $xfer += $output->writeFieldBegin('expungedNotebooks', TType::LIST, 10);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedNotebooks}}));
      {
        foreach my $iter72 (@{$self->{expungedNotebooks}}) 
        {
          $xfer += $output->writeString($iter72);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expungedTags}) {
    $xfer += $output->writeFieldBegin('expungedTags', TType::LIST, 11);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedTags}}));
      {
        foreach my $iter73 (@{$self->{expungedTags}}) 
        {
          $xfer += $output->writeString($iter73);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expungedSearches}) {
    $xfer += $output->writeFieldBegin('expungedSearches', TType::LIST, 12);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedSearches}}));
      {
        foreach my $iter74 (@{$self->{expungedSearches}}) 
        {
          $xfer += $output->writeString($iter74);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{linkedNotebooks}) {
    $xfer += $output->writeFieldBegin('linkedNotebooks', TType::LIST, 13);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{linkedNotebooks}}));
      {
        foreach my $iter75 (@{$self->{linkedNotebooks}}) 
        {
          $xfer += ${iter75}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expungedLinkedNotebooks}) {
    $xfer += $output->writeFieldBegin('expungedLinkedNotebooks', TType::LIST, 14);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedLinkedNotebooks}}));
      {
        foreach my $iter76 (@{$self->{expungedLinkedNotebooks}}) 
        {
          $xfer += $output->writeString($iter76);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::SyncChunkFilter;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::SyncChunkFilter->mk_accessors( qw( includeNotes includeNoteResources includeNoteAttributes includeNotebooks includeTags includeSearches includeResources includeLinkedNotebooks includeExpunged includeNoteApplicationDataFu...

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{includeNotes} = undef;
  $self->{includeNoteResources} = undef;
  $self->{includeNoteAttributes} = undef;
  $self->{includeNotebooks} = undef;
  $self->{includeTags} = undef;
  $self->{includeSearches} = undef;
  $self->{includeResources} = undef;
  $self->{includeLinkedNotebooks} = undef;
  $self->{includeExpunged} = undef;
  $self->{includeNoteApplicationDataFullMap} = undef;
  $self->{includeResourceApplicationDataFullMap} = undef;
  $self->{includeNoteResourceApplicationDataFullMap} = undef;
  $self->{requireNoteContentClass} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{includeNotes}) {
      $self->{includeNotes} = $vals->{includeNotes};
    }
    if (defined $vals->{includeNoteResources}) {
      $self->{includeNoteResources} = $vals->{includeNoteResources};
    }
    if (defined $vals->{includeNoteAttributes}) {
      $self->{includeNoteAttributes} = $vals->{includeNoteAttributes};
    }
    if (defined $vals->{includeNotebooks}) {
      $self->{includeNotebooks} = $vals->{includeNotebooks};
    }
    if (defined $vals->{includeTags}) {
      $self->{includeTags} = $vals->{includeTags};
    }
    if (defined $vals->{includeSearches}) {
      $self->{includeSearches} = $vals->{includeSearches};
    }
    if (defined $vals->{includeResources}) {
      $self->{includeResources} = $vals->{includeResources};
    }
    if (defined $vals->{includeLinkedNotebooks}) {
      $self->{includeLinkedNotebooks} = $vals->{includeLinkedNotebooks};
    }
    if (defined $vals->{includeExpunged}) {
      $self->{includeExpunged} = $vals->{includeExpunged};
    }
    if (defined $vals->{includeNoteApplicationDataFullMap}) {
      $self->{includeNoteApplicationDataFullMap} = $vals->{includeNoteApplicationDataFullMap};
    }
    if (defined $vals->{includeResourceApplicationDataFullMap}) {
      $self->{includeResourceApplicationDataFullMap} = $vals->{includeResourceApplicationDataFullMap};
    }
    if (defined $vals->{includeNoteResourceApplicationDataFullMap}) {
      $self->{includeNoteResourceApplicationDataFullMap} = $vals->{includeNoteResourceApplicationDataFullMap};
    }
    if (defined $vals->{requireNoteContentClass}) {
      $self->{requireNoteContentClass} = $vals->{requireNoteContentClass};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'SyncChunkFilter';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNotes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNoteResources});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNoteAttributes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNotebooks});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeTags});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeSearches});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeResources});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeLinkedNotebooks});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeExpunged});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNoteApplicationDataFullMap});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeResourceApplicationDataFullMap});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNoteResourceApplicationDataFullMap});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{requireNoteContentClass});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('SyncChunkFilter');
  if (defined $self->{includeNotes}) {
    $xfer += $output->writeFieldBegin('includeNotes', TType::BOOL, 1);
    $xfer += $output->writeBool($self->{includeNotes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNoteResources}) {
    $xfer += $output->writeFieldBegin('includeNoteResources', TType::BOOL, 2);
    $xfer += $output->writeBool($self->{includeNoteResources});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNoteAttributes}) {
    $xfer += $output->writeFieldBegin('includeNoteAttributes', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{includeNoteAttributes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNotebooks}) {
    $xfer += $output->writeFieldBegin('includeNotebooks', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{includeNotebooks});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeTags}) {
    $xfer += $output->writeFieldBegin('includeTags', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{includeTags});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeSearches}) {
    $xfer += $output->writeFieldBegin('includeSearches', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{includeSearches});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeResources}) {
    $xfer += $output->writeFieldBegin('includeResources', TType::BOOL, 7);
    $xfer += $output->writeBool($self->{includeResources});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeLinkedNotebooks}) {
    $xfer += $output->writeFieldBegin('includeLinkedNotebooks', TType::BOOL, 8);
    $xfer += $output->writeBool($self->{includeLinkedNotebooks});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeExpunged}) {
    $xfer += $output->writeFieldBegin('includeExpunged', TType::BOOL, 9);
    $xfer += $output->writeBool($self->{includeExpunged});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNoteApplicationDataFullMap}) {
    $xfer += $output->writeFieldBegin('includeNoteApplicationDataFullMap', TType::BOOL, 10);
    $xfer += $output->writeBool($self->{includeNoteApplicationDataFullMap});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{requireNoteContentClass}) {
    $xfer += $output->writeFieldBegin('requireNoteContentClass', TType::STRING, 11);
    $xfer += $output->writeString($self->{requireNoteContentClass});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeResourceApplicationDataFullMap}) {
    $xfer += $output->writeFieldBegin('includeResourceApplicationDataFullMap', TType::BOOL, 12);
    $xfer += $output->writeBool($self->{includeResourceApplicationDataFullMap});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNoteResourceApplicationDataFullMap}) {
    $xfer += $output->writeFieldBegin('includeNoteResourceApplicationDataFullMap', TType::BOOL, 13);
    $xfer += $output->writeBool($self->{includeNoteResourceApplicationDataFullMap});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteFilter;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteFilter->mk_accessors( qw( order ascending words notebookGuid tagGuids timeZone inactive ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{order} = undef;
  $self->{ascending} = undef;
  $self->{words} = undef;
  $self->{notebookGuid} = undef;
  $self->{tagGuids} = undef;
  $self->{timeZone} = undef;
  $self->{inactive} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{order}) {
      $self->{order} = $vals->{order};
    }
    if (defined $vals->{ascending}) {
      $self->{ascending} = $vals->{ascending};
    }
    if (defined $vals->{words}) {
      $self->{words} = $vals->{words};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
    if (defined $vals->{tagGuids}) {
      $self->{tagGuids} = $vals->{tagGuids};
    }
    if (defined $vals->{timeZone}) {
      $self->{timeZone} = $vals->{timeZone};
    }
    if (defined $vals->{inactive}) {
      $self->{inactive} = $vals->{inactive};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteFilter';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{order});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{ascending});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{words});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size77 = 0;
          $self->{tagGuids} = [];
          my $_etype80 = 0;
          $xfer += $input->readListBegin(\$_etype80, \$_size77);
          for (my $_i81 = 0; $_i81 < $_size77; ++$_i81)
          {
            my $elem82 = undef;
            $xfer += $input->readString(\$elem82);
            push(@{$self->{tagGuids}},$elem82);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{timeZone});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{inactive});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteFilter');
  if (defined $self->{order}) {
    $xfer += $output->writeFieldBegin('order', TType::I32, 1);
    $xfer += $output->writeI32($self->{order});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{ascending}) {
    $xfer += $output->writeFieldBegin('ascending', TType::BOOL, 2);
    $xfer += $output->writeBool($self->{ascending});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{words}) {
    $xfer += $output->writeFieldBegin('words', TType::STRING, 3);
    $xfer += $output->writeString($self->{words});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 4);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tagGuids}) {
    $xfer += $output->writeFieldBegin('tagGuids', TType::LIST, 5);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagGuids}}));
      {
        foreach my $iter83 (@{$self->{tagGuids}}) 
        {
          $xfer += $output->writeString($iter83);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{timeZone}) {
    $xfer += $output->writeFieldBegin('timeZone', TType::STRING, 6);
    $xfer += $output->writeString($self->{timeZone});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{inactive}) {
    $xfer += $output->writeFieldBegin('inactive', TType::BOOL, 7);
    $xfer += $output->writeBool($self->{inactive});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteList;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteList->mk_accessors( qw( startIndex totalNotes notes stoppedWords searchedWords updateCount ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{startIndex} = undef;
  $self->{totalNotes} = undef;
  $self->{notes} = undef;
  $self->{stoppedWords} = undef;
  $self->{searchedWords} = undef;
  $self->{updateCount} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{startIndex}) {
      $self->{startIndex} = $vals->{startIndex};
    }
    if (defined $vals->{totalNotes}) {
      $self->{totalNotes} = $vals->{totalNotes};
    }
    if (defined $vals->{notes}) {
      $self->{notes} = $vals->{notes};
    }
    if (defined $vals->{stoppedWords}) {
      $self->{stoppedWords} = $vals->{stoppedWords};
    }
    if (defined $vals->{searchedWords}) {
      $self->{searchedWords} = $vals->{searchedWords};
    }
    if (defined $vals->{updateCount}) {
      $self->{updateCount} = $vals->{updateCount};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteList';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{startIndex});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{totalNotes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size84 = 0;
          $self->{notes} = [];
          my $_etype87 = 0;
          $xfer += $input->readListBegin(\$_etype87, \$_size84);
          for (my $_i88 = 0; $_i88 < $_size84; ++$_i88)
          {
            my $elem89 = undef;
            $elem89 = Net::Evernote::EDAMTypes::Note->new();
            $xfer += $elem89->read($input);
            push(@{$self->{notes}},$elem89);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size90 = 0;
          $self->{stoppedWords} = [];
          my $_etype93 = 0;
          $xfer += $input->readListBegin(\$_etype93, \$_size90);
          for (my $_i94 = 0; $_i94 < $_size90; ++$_i94)
          {
            my $elem95 = undef;
            $xfer += $input->readString(\$elem95);
            push(@{$self->{stoppedWords}},$elem95);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size96 = 0;
          $self->{searchedWords} = [];
          my $_etype99 = 0;
          $xfer += $input->readListBegin(\$_etype99, \$_size96);
          for (my $_i100 = 0; $_i100 < $_size96; ++$_i100)
          {
            my $elem101 = undef;
            $xfer += $input->readString(\$elem101);
            push(@{$self->{searchedWords}},$elem101);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteList');
  if (defined $self->{startIndex}) {
    $xfer += $output->writeFieldBegin('startIndex', TType::I32, 1);
    $xfer += $output->writeI32($self->{startIndex});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{totalNotes}) {
    $xfer += $output->writeFieldBegin('totalNotes', TType::I32, 2);
    $xfer += $output->writeI32($self->{totalNotes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notes}) {
    $xfer += $output->writeFieldBegin('notes', TType::LIST, 3);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
      {
        foreach my $iter102 (@{$self->{notes}}) 
        {
          $xfer += ${iter102}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{stoppedWords}) {
    $xfer += $output->writeFieldBegin('stoppedWords', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{stoppedWords}}));
      {
        foreach my $iter103 (@{$self->{stoppedWords}}) 
        {
          $xfer += $output->writeString($iter103);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{searchedWords}) {
    $xfer += $output->writeFieldBegin('searchedWords', TType::LIST, 5);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{searchedWords}}));
      {
        foreach my $iter104 (@{$self->{searchedWords}}) 
        {
          $xfer += $output->writeString($iter104);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateCount}) {
    $xfer += $output->writeFieldBegin('updateCount', TType::I32, 6);
    $xfer += $output->writeI32($self->{updateCount});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteMetadata;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteMetadata->mk_accessors( qw( guid title contentLength created updated updateSequenceNum notebookGuid tagGuids attributes largestResourceMime largestResourceSize ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{title} = undef;
  $self->{contentLength} = undef;
  $self->{created} = undef;
  $self->{updated} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{notebookGuid} = undef;
  $self->{tagGuids} = undef;
  $self->{attributes} = undef;
  $self->{largestResourceMime} = undef;
  $self->{largestResourceSize} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{title}) {
      $self->{title} = $vals->{title};
    }
    if (defined $vals->{contentLength}) {
      $self->{contentLength} = $vals->{contentLength};
    }
    if (defined $vals->{created}) {
      $self->{created} = $vals->{created};
    }
    if (defined $vals->{updated}) {
      $self->{updated} = $vals->{updated};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
    if (defined $vals->{tagGuids}) {
      $self->{tagGuids} = $vals->{tagGuids};
    }
    if (defined $vals->{attributes}) {
      $self->{attributes} = $vals->{attributes};
    }
    if (defined $vals->{largestResourceMime}) {
      $self->{largestResourceMime} = $vals->{largestResourceMime};
    }
    if (defined $vals->{largestResourceSize}) {
      $self->{largestResourceSize} = $vals->{largestResourceSize};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteMetadata';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{title});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{contentLength});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{created});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{updated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size105 = 0;
          $self->{tagGuids} = [];
          my $_etype108 = 0;
          $xfer += $input->readListBegin(\$_etype108, \$_size105);
          for (my $_i109 = 0; $_i109 < $_size105; ++$_i109)
          {
            my $elem110 = undef;
            $xfer += $input->readString(\$elem110);
            push(@{$self->{tagGuids}},$elem110);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{attributes} = Net::Evernote::EDAMTypes::NoteAttributes->new();
        $xfer += $self->{attributes}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^20$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{largestResourceMime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^21$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{largestResourceSize});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteMetadata');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{title}) {
    $xfer += $output->writeFieldBegin('title', TType::STRING, 2);
    $xfer += $output->writeString($self->{title});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{contentLength}) {
    $xfer += $output->writeFieldBegin('contentLength', TType::I32, 5);
    $xfer += $output->writeI32($self->{contentLength});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{created}) {
    $xfer += $output->writeFieldBegin('created', TType::I64, 6);
    $xfer += $output->writeI64($self->{created});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updated}) {
    $xfer += $output->writeFieldBegin('updated', TType::I64, 7);
    $xfer += $output->writeI64($self->{updated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 10);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 11);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tagGuids}) {
    $xfer += $output->writeFieldBegin('tagGuids', TType::LIST, 12);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagGuids}}));
      {
        foreach my $iter111 (@{$self->{tagGuids}}) 
        {
          $xfer += $output->writeString($iter111);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{attributes}) {
    $xfer += $output->writeFieldBegin('attributes', TType::STRUCT, 14);
    $xfer += $self->{attributes}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{largestResourceMime}) {
    $xfer += $output->writeFieldBegin('largestResourceMime', TType::STRING, 20);
    $xfer += $output->writeString($self->{largestResourceMime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{largestResourceSize}) {
    $xfer += $output->writeFieldBegin('largestResourceSize', TType::I32, 21);
    $xfer += $output->writeI32($self->{largestResourceSize});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NotesMetadataList;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NotesMetadataList->mk_accessors( qw( startIndex totalNotes notes stoppedWords searchedWords updateCount ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{startIndex} = undef;
  $self->{totalNotes} = undef;
  $self->{notes} = undef;
  $self->{stoppedWords} = undef;
  $self->{searchedWords} = undef;
  $self->{updateCount} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{startIndex}) {
      $self->{startIndex} = $vals->{startIndex};
    }
    if (defined $vals->{totalNotes}) {
      $self->{totalNotes} = $vals->{totalNotes};
    }
    if (defined $vals->{notes}) {
      $self->{notes} = $vals->{notes};
    }
    if (defined $vals->{stoppedWords}) {
      $self->{stoppedWords} = $vals->{stoppedWords};
    }
    if (defined $vals->{searchedWords}) {
      $self->{searchedWords} = $vals->{searchedWords};
    }
    if (defined $vals->{updateCount}) {
      $self->{updateCount} = $vals->{updateCount};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NotesMetadataList';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{startIndex});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{totalNotes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size112 = 0;
          $self->{notes} = [];
          my $_etype115 = 0;
          $xfer += $input->readListBegin(\$_etype115, \$_size112);
          for (my $_i116 = 0; $_i116 < $_size112; ++$_i116)
          {
            my $elem117 = undef;
            $elem117 = Net::Evernote::EDAMNoteStore::NoteMetadata->new();
            $xfer += $elem117->read($input);
            push(@{$self->{notes}},$elem117);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size118 = 0;
          $self->{stoppedWords} = [];
          my $_etype121 = 0;
          $xfer += $input->readListBegin(\$_etype121, \$_size118);
          for (my $_i122 = 0; $_i122 < $_size118; ++$_i122)
          {
            my $elem123 = undef;
            $xfer += $input->readString(\$elem123);
            push(@{$self->{stoppedWords}},$elem123);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size124 = 0;
          $self->{searchedWords} = [];
          my $_etype127 = 0;
          $xfer += $input->readListBegin(\$_etype127, \$_size124);
          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
          {
            my $elem129 = undef;
            $xfer += $input->readString(\$elem129);
            push(@{$self->{searchedWords}},$elem129);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NotesMetadataList');
  if (defined $self->{startIndex}) {
    $xfer += $output->writeFieldBegin('startIndex', TType::I32, 1);
    $xfer += $output->writeI32($self->{startIndex});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{totalNotes}) {
    $xfer += $output->writeFieldBegin('totalNotes', TType::I32, 2);
    $xfer += $output->writeI32($self->{totalNotes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notes}) {
    $xfer += $output->writeFieldBegin('notes', TType::LIST, 3);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
      {
        foreach my $iter130 (@{$self->{notes}}) 
        {
          $xfer += ${iter130}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{stoppedWords}) {
    $xfer += $output->writeFieldBegin('stoppedWords', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{stoppedWords}}));
      {
        foreach my $iter131 (@{$self->{stoppedWords}}) 
        {
          $xfer += $output->writeString($iter131);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{searchedWords}) {
    $xfer += $output->writeFieldBegin('searchedWords', TType::LIST, 5);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{searchedWords}}));
      {
        foreach my $iter132 (@{$self->{searchedWords}}) 
        {
          $xfer += $output->writeString($iter132);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateCount}) {
    $xfer += $output->writeFieldBegin('updateCount', TType::I32, 6);
    $xfer += $output->writeI32($self->{updateCount});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec->mk_accessors( qw( includeTitle includeContentLength includeCreated includeUpdated includeUpdateSequenceNum includeNotebookGuid includeTagGuids includeAttributes includeLargestResourceMime include...

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{includeTitle} = undef;
  $self->{includeContentLength} = undef;
  $self->{includeCreated} = undef;
  $self->{includeUpdated} = undef;
  $self->{includeUpdateSequenceNum} = undef;
  $self->{includeNotebookGuid} = undef;
  $self->{includeTagGuids} = undef;
  $self->{includeAttributes} = undef;
  $self->{includeLargestResourceMime} = undef;
  $self->{includeLargestResourceSize} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{includeTitle}) {
      $self->{includeTitle} = $vals->{includeTitle};
    }
    if (defined $vals->{includeContentLength}) {
      $self->{includeContentLength} = $vals->{includeContentLength};
    }
    if (defined $vals->{includeCreated}) {
      $self->{includeCreated} = $vals->{includeCreated};
    }
    if (defined $vals->{includeUpdated}) {
      $self->{includeUpdated} = $vals->{includeUpdated};
    }
    if (defined $vals->{includeUpdateSequenceNum}) {
      $self->{includeUpdateSequenceNum} = $vals->{includeUpdateSequenceNum};
    }
    if (defined $vals->{includeNotebookGuid}) {
      $self->{includeNotebookGuid} = $vals->{includeNotebookGuid};
    }
    if (defined $vals->{includeTagGuids}) {
      $self->{includeTagGuids} = $vals->{includeTagGuids};
    }
    if (defined $vals->{includeAttributes}) {
      $self->{includeAttributes} = $vals->{includeAttributes};
    }
    if (defined $vals->{includeLargestResourceMime}) {
      $self->{includeLargestResourceMime} = $vals->{includeLargestResourceMime};
    }
    if (defined $vals->{includeLargestResourceSize}) {
      $self->{includeLargestResourceSize} = $vals->{includeLargestResourceSize};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NotesMetadataResultSpec';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^2$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeTitle});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeContentLength});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeCreated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeUpdated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeUpdateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeNotebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeTagGuids});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeAttributes});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^20$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeLargestResourceMime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^21$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{includeLargestResourceSize});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NotesMetadataResultSpec');
  if (defined $self->{includeTitle}) {
    $xfer += $output->writeFieldBegin('includeTitle', TType::BOOL, 2);
    $xfer += $output->writeBool($self->{includeTitle});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeContentLength}) {
    $xfer += $output->writeFieldBegin('includeContentLength', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{includeContentLength});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeCreated}) {
    $xfer += $output->writeFieldBegin('includeCreated', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{includeCreated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeUpdated}) {
    $xfer += $output->writeFieldBegin('includeUpdated', TType::BOOL, 7);
    $xfer += $output->writeBool($self->{includeUpdated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeUpdateSequenceNum}) {
    $xfer += $output->writeFieldBegin('includeUpdateSequenceNum', TType::BOOL, 10);
    $xfer += $output->writeBool($self->{includeUpdateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeNotebookGuid}) {
    $xfer += $output->writeFieldBegin('includeNotebookGuid', TType::BOOL, 11);
    $xfer += $output->writeBool($self->{includeNotebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeTagGuids}) {
    $xfer += $output->writeFieldBegin('includeTagGuids', TType::BOOL, 12);
    $xfer += $output->writeBool($self->{includeTagGuids});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeAttributes}) {
    $xfer += $output->writeFieldBegin('includeAttributes', TType::BOOL, 14);
    $xfer += $output->writeBool($self->{includeAttributes});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeLargestResourceMime}) {
    $xfer += $output->writeFieldBegin('includeLargestResourceMime', TType::BOOL, 20);
    $xfer += $output->writeBool($self->{includeLargestResourceMime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{includeLargestResourceSize}) {
    $xfer += $output->writeFieldBegin('includeLargestResourceSize', TType::BOOL, 21);
    $xfer += $output->writeBool($self->{includeLargestResourceSize});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteCollectionCounts;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteCollectionCounts->mk_accessors( qw( notebookCounts tagCounts trashCount ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{notebookCounts} = undef;
  $self->{tagCounts} = undef;
  $self->{trashCount} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{notebookCounts}) {
      $self->{notebookCounts} = $vals->{notebookCounts};
    }
    if (defined $vals->{tagCounts}) {
      $self->{tagCounts} = $vals->{tagCounts};
    }
    if (defined $vals->{trashCount}) {
      $self->{trashCount} = $vals->{trashCount};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteCollectionCounts';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::MAP) {
        {
          my $_size133 = 0;
          $self->{notebookCounts} = {};
          my $_ktype134 = 0;
          my $_vtype135 = 0;
          $xfer += $input->readMapBegin(\$_ktype134, \$_vtype135, \$_size133);
          for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
          {
            my $key138 = '';
            my $val139 = 0;
            $xfer += $input->readString(\$key138);
            $xfer += $input->readI32(\$val139);
            $self->{notebookCounts}->{$key138} = $val139;
          }
          $xfer += $input->readMapEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::MAP) {
        {
          my $_size140 = 0;
          $self->{tagCounts} = {};
          my $_ktype141 = 0;
          my $_vtype142 = 0;
          $xfer += $input->readMapBegin(\$_ktype141, \$_vtype142, \$_size140);
          for (my $_i144 = 0; $_i144 < $_size140; ++$_i144)
          {
            my $key145 = '';
            my $val146 = 0;
            $xfer += $input->readString(\$key145);
            $xfer += $input->readI32(\$val146);
            $self->{tagCounts}->{$key145} = $val146;
          }
          $xfer += $input->readMapEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{trashCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteCollectionCounts');
  if (defined $self->{notebookCounts}) {
    $xfer += $output->writeFieldBegin('notebookCounts', TType::MAP, 1);
    {
      $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{$self->{notebookCounts}}));
      {
        while( my ($kiter147,$viter148) = each %{$self->{notebookCounts}}) 
        {
          $xfer += $output->writeString($kiter147);
          $xfer += $output->writeI32($viter148);
        }
      }
      $xfer += $output->writeMapEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tagCounts}) {
    $xfer += $output->writeFieldBegin('tagCounts', TType::MAP, 2);
    {
      $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{$self->{tagCounts}}));
      {
        while( my ($kiter149,$viter150) = each %{$self->{tagCounts}}) 
        {
          $xfer += $output->writeString($kiter149);
          $xfer += $output->writeI32($viter150);
        }
      }
      $xfer += $output->writeMapEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{trashCount}) {
    $xfer += $output->writeFieldBegin('trashCount', TType::I32, 3);
    $xfer += $output->writeI32($self->{trashCount});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::AdImpressions;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::AdImpressions->mk_accessors( qw( adId impressionCount impressionTime ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{adId} = undef;
  $self->{impressionCount} = undef;
  $self->{impressionTime} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{adId}) {
      $self->{adId} = $vals->{adId};
    }
    if (defined $vals->{impressionCount}) {
      $self->{impressionCount} = $vals->{impressionCount};
    }
    if (defined $vals->{impressionTime}) {
      $self->{impressionTime} = $vals->{impressionTime};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'AdImpressions';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{adId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{impressionCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{impressionTime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('AdImpressions');
  if (defined $self->{adId}) {
    $xfer += $output->writeFieldBegin('adId', TType::I32, 1);
    $xfer += $output->writeI32($self->{adId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{impressionCount}) {
    $xfer += $output->writeFieldBegin('impressionCount', TType::I32, 2);
    $xfer += $output->writeI32($self->{impressionCount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{impressionTime}) {
    $xfer += $output->writeFieldBegin('impressionTime', TType::I32, 3);
    $xfer += $output->writeI32($self->{impressionTime});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::AdParameters;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::AdParameters->mk_accessors( qw( clientLanguage impressions supportHtml clientProperties ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{clientLanguage} = undef;
  $self->{impressions} = undef;
  $self->{supportHtml} = undef;
  $self->{clientProperties} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{clientLanguage}) {
      $self->{clientLanguage} = $vals->{clientLanguage};
    }
    if (defined $vals->{impressions}) {
      $self->{impressions} = $vals->{impressions};
    }
    if (defined $vals->{supportHtml}) {
      $self->{supportHtml} = $vals->{supportHtml};
    }
    if (defined $vals->{clientProperties}) {
      $self->{clientProperties} = $vals->{clientProperties};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'AdParameters';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{clientLanguage});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size151 = 0;
          $self->{impressions} = [];
          my $_etype154 = 0;
          $xfer += $input->readListBegin(\$_etype154, \$_size151);
          for (my $_i155 = 0; $_i155 < $_size151; ++$_i155)
          {
            my $elem156 = undef;
            $elem156 = Net::Evernote::EDAMNoteStore::AdImpressions->new();
            $xfer += $elem156->read($input);
            push(@{$self->{impressions}},$elem156);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{supportHtml});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::MAP) {
        {
          my $_size157 = 0;
          $self->{clientProperties} = {};
          my $_ktype158 = 0;
          my $_vtype159 = 0;
          $xfer += $input->readMapBegin(\$_ktype158, \$_vtype159, \$_size157);
          for (my $_i161 = 0; $_i161 < $_size157; ++$_i161)
          {
            my $key162 = '';
            my $val163 = '';
            $xfer += $input->readString(\$key162);
            $xfer += $input->readString(\$val163);
            $self->{clientProperties}->{$key162} = $val163;
          }
          $xfer += $input->readMapEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('AdParameters');
  if (defined $self->{clientLanguage}) {
    $xfer += $output->writeFieldBegin('clientLanguage', TType::STRING, 2);
    $xfer += $output->writeString($self->{clientLanguage});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{impressions}) {
    $xfer += $output->writeFieldBegin('impressions', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{impressions}}));
      {
        foreach my $iter164 (@{$self->{impressions}}) 
        {
          $xfer += ${iter164}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{supportHtml}) {
    $xfer += $output->writeFieldBegin('supportHtml', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{supportHtml});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{clientProperties}) {
    $xfer += $output->writeFieldBegin('clientProperties', TType::MAP, 6);
    {
      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{clientProperties}}));
      {
        while( my ($kiter165,$viter166) = each %{$self->{clientProperties}}) 
        {
          $xfer += $output->writeString($kiter165);
          $xfer += $output->writeString($viter166);
        }
      }
      $xfer += $output->writeMapEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteEmailParameters;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteEmailParameters->mk_accessors( qw( guid note toAddresses ccAddresses subject message ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{note} = undef;
  $self->{toAddresses} = undef;
  $self->{ccAddresses} = undef;
  $self->{subject} = undef;
  $self->{message} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{note}) {
      $self->{note} = $vals->{note};
    }
    if (defined $vals->{toAddresses}) {
      $self->{toAddresses} = $vals->{toAddresses};
    }
    if (defined $vals->{ccAddresses}) {
      $self->{ccAddresses} = $vals->{ccAddresses};
    }
    if (defined $vals->{subject}) {
      $self->{subject} = $vals->{subject};
    }
    if (defined $vals->{message}) {
      $self->{message} = $vals->{message};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteEmailParameters';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{note} = Net::Evernote::EDAMTypes::Note->new();
        $xfer += $self->{note}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size167 = 0;
          $self->{toAddresses} = [];
          my $_etype170 = 0;
          $xfer += $input->readListBegin(\$_etype170, \$_size167);
          for (my $_i171 = 0; $_i171 < $_size167; ++$_i171)
          {
            my $elem172 = undef;
            $xfer += $input->readString(\$elem172);
            push(@{$self->{toAddresses}},$elem172);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size173 = 0;
          $self->{ccAddresses} = [];
          my $_etype176 = 0;
          $xfer += $input->readListBegin(\$_etype176, \$_size173);
          for (my $_i177 = 0; $_i177 < $_size173; ++$_i177)
          {
            my $elem178 = undef;
            $xfer += $input->readString(\$elem178);
            push(@{$self->{ccAddresses}},$elem178);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{subject});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{message});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteEmailParameters');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{note}) {
    $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
    $xfer += $self->{note}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{toAddresses}) {
    $xfer += $output->writeFieldBegin('toAddresses', TType::LIST, 3);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{toAddresses}}));
      {
        foreach my $iter179 (@{$self->{toAddresses}}) 
        {
          $xfer += $output->writeString($iter179);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{ccAddresses}) {
    $xfer += $output->writeFieldBegin('ccAddresses', TType::LIST, 4);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{ccAddresses}}));
      {
        foreach my $iter180 (@{$self->{ccAddresses}}) 
        {
          $xfer += $output->writeString($iter180);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{subject}) {
    $xfer += $output->writeFieldBegin('subject', TType::STRING, 5);
    $xfer += $output->writeString($self->{subject});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{message}) {
    $xfer += $output->writeFieldBegin('message', TType::STRING, 6);
    $xfer += $output->writeString($self->{message});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMNoteStore::NoteVersionId;
use base qw(Class::Accessor);
Net::Evernote::EDAMNoteStore::NoteVersionId->mk_accessors( qw( updateSequenceNum updated saved title ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{updateSequenceNum} = undef;
  $self->{updated} = undef;
  $self->{saved} = undef;
  $self->{title} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{updated}) {
      $self->{updated} = $vals->{updated};
    }
    if (defined $vals->{saved}) {
      $self->{saved} = $vals->{saved};
    }
    if (defined $vals->{title}) {
      $self->{title} = $vals->{title};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteVersionId';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{updated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{saved});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{title});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteVersionId');
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 1);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updated}) {
    $xfer += $output->writeFieldBegin('updated', TType::I64, 2);
    $xfer += $output->writeI64($self->{updated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{saved}) {
    $xfer += $output->writeFieldBegin('saved', TType::I64, 3);
    $xfer += $output->writeI64($self->{saved});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{title}) {
    $xfer += $output->writeFieldBegin('title', TType::STRING, 4);
    $xfer += $output->writeString($self->{title});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

1;

lib/Net/Evernote/EDAMTypes/Constants.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
package Net::Evernote::EDAMTypes::Constants;
require 5.6.0;
use strict;
use warnings;
use Thrift;


use constant EDAM_NOTE_SOURCE_WEB_CLIP => "web.clip";

use constant EDAM_NOTE_SOURCE_MAIL_CLIP => "mail.clip";

use constant EDAM_NOTE_SOURCE_MAIL_SMTP_GATEWAY => "mail.smtp";

1;

lib/Net/Evernote/EDAMTypes/Types.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

package Net::Evernote::EDAMTypes::PrivilegeLevel;
use constant NORMAL => 1;
use constant PREMIUM => 3;
use constant MANAGER => 7;
use constant SUPPORT => 8;
use constant ADMIN => 9;
package Net::Evernote::EDAMTypes::QueryFormat;
use constant USER => 1;
use constant SEXP => 2;
package Net::Evernote::EDAMTypes::NoteSortOrder;
use constant CREATED => 1;
use constant UPDATED => 2;
use constant RELEVANCE => 3;
use constant UPDATE_SEQUENCE_NUMBER => 4;
use constant TITLE => 5;
package Net::Evernote::EDAMTypes::PremiumOrderStatus;
use constant NONE => 0;
use constant PENDING => 1;
use constant ACTIVE => 2;
use constant FAILED => 3;
use constant CANCELLATION_PENDING => 4;
use constant CANCELED => 5;
package Net::Evernote::EDAMTypes::Data;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Data->mk_accessors( qw( bodyHash size body ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{bodyHash} = undef;
  $self->{size} = undef;
  $self->{body} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{bodyHash}) {
      $self->{bodyHash} = $vals->{bodyHash};
    }
    if (defined $vals->{size}) {
      $self->{size} = $vals->{size};
    }
    if (defined $vals->{body}) {
      $self->{body} = $vals->{body};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Data';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{bodyHash});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{size});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{body});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Data');
  if (defined $self->{bodyHash}) {
    $xfer += $output->writeFieldBegin('bodyHash', TType::STRING, 1);
    $xfer += $output->writeString($self->{bodyHash});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{size}) {
    $xfer += $output->writeFieldBegin('size', TType::I32, 2);
    $xfer += $output->writeI32($self->{size});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{body}) {
    $xfer += $output->writeFieldBegin('body', TType::STRING, 3);
    $xfer += $output->writeString($self->{body});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::UserAttributes;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::UserAttributes->mk_accessors( qw( defaultLocationName defaultLatitude defaultLongitude preactivation viewedPromotions incomingEmailAddress recentMailedAddresses comments dateAgreedToTermsOfService maxReferrals referralCount ...

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{defaultLocationName} = undef;
  $self->{defaultLatitude} = undef;
  $self->{defaultLongitude} = undef;
  $self->{preactivation} = undef;
  $self->{viewedPromotions} = undef;
  $self->{incomingEmailAddress} = undef;
  $self->{recentMailedAddresses} = undef;
  $self->{comments} = undef;
  $self->{dateAgreedToTermsOfService} = undef;
  $self->{maxReferrals} = undef;
  $self->{referralCount} = undef;
  $self->{refererCode} = undef;
  $self->{sentEmailDate} = undef;
  $self->{sentEmailCount} = undef;
  $self->{dailyEmailLimit} = undef;
  $self->{emailOptOutDate} = undef;
  $self->{partnerEmailOptInDate} = undef;
  $self->{preferredLanguage} = undef;
  $self->{preferredCountry} = undef;
  $self->{clipFullPage} = undef;
  $self->{twitterUserName} = undef;
  $self->{twitterId} = undef;
  $self->{groupName} = undef;
  $self->{recognitionLanguage} = undef;
  $self->{customerProfileId} = undef;
  $self->{referralProof} = undef;
  $self->{educationalDiscount} = undef;
  $self->{businessAddress} = undef;
  $self->{hideSponsorBilling} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{defaultLocationName}) {
      $self->{defaultLocationName} = $vals->{defaultLocationName};
    }
    if (defined $vals->{defaultLatitude}) {
      $self->{defaultLatitude} = $vals->{defaultLatitude};
    }
    if (defined $vals->{defaultLongitude}) {
      $self->{defaultLongitude} = $vals->{defaultLongitude};
    }
    if (defined $vals->{preactivation}) {
      $self->{preactivation} = $vals->{preactivation};
    }
    if (defined $vals->{viewedPromotions}) {
      $self->{viewedPromotions} = $vals->{viewedPromotions};
    }
    if (defined $vals->{incomingEmailAddress}) {
      $self->{incomingEmailAddress} = $vals->{incomingEmailAddress};
    }
    if (defined $vals->{recentMailedAddresses}) {
      $self->{recentMailedAddresses} = $vals->{recentMailedAddresses};
    }
    if (defined $vals->{comments}) {
      $self->{comments} = $vals->{comments};
    }
    if (defined $vals->{dateAgreedToTermsOfService}) {
      $self->{dateAgreedToTermsOfService} = $vals->{dateAgreedToTermsOfService};
    }
    if (defined $vals->{maxReferrals}) {
      $self->{maxReferrals} = $vals->{maxReferrals};
    }
    if (defined $vals->{referralCount}) {
      $self->{referralCount} = $vals->{referralCount};
    }
    if (defined $vals->{refererCode}) {
      $self->{refererCode} = $vals->{refererCode};
    }
    if (defined $vals->{sentEmailDate}) {
      $self->{sentEmailDate} = $vals->{sentEmailDate};
    }
    if (defined $vals->{sentEmailCount}) {
      $self->{sentEmailCount} = $vals->{sentEmailCount};
    }
    if (defined $vals->{dailyEmailLimit}) {
      $self->{dailyEmailLimit} = $vals->{dailyEmailLimit};
    }
    if (defined $vals->{emailOptOutDate}) {
      $self->{emailOptOutDate} = $vals->{emailOptOutDate};
    }
    if (defined $vals->{partnerEmailOptInDate}) {
      $self->{partnerEmailOptInDate} = $vals->{partnerEmailOptInDate};
    }
    if (defined $vals->{preferredLanguage}) {
      $self->{preferredLanguage} = $vals->{preferredLanguage};
    }
    if (defined $vals->{preferredCountry}) {
      $self->{preferredCountry} = $vals->{preferredCountry};
    }
    if (defined $vals->{clipFullPage}) {
      $self->{clipFullPage} = $vals->{clipFullPage};
    }
    if (defined $vals->{twitterUserName}) {
      $self->{twitterUserName} = $vals->{twitterUserName};
    }
    if (defined $vals->{twitterId}) {
      $self->{twitterId} = $vals->{twitterId};
    }
    if (defined $vals->{groupName}) {
      $self->{groupName} = $vals->{groupName};
    }
    if (defined $vals->{recognitionLanguage}) {
      $self->{recognitionLanguage} = $vals->{recognitionLanguage};
    }
    if (defined $vals->{customerProfileId}) {
      $self->{customerProfileId} = $vals->{customerProfileId};
    }
    if (defined $vals->{referralProof}) {
      $self->{referralProof} = $vals->{referralProof};
    }
    if (defined $vals->{educationalDiscount}) {
      $self->{educationalDiscount} = $vals->{educationalDiscount};
    }
    if (defined $vals->{businessAddress}) {
      $self->{businessAddress} = $vals->{businessAddress};
    }
    if (defined $vals->{hideSponsorBilling}) {
      $self->{hideSponsorBilling} = $vals->{hideSponsorBilling};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserAttributes';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{defaultLocationName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{defaultLatitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{defaultLongitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{preactivation});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size0 = 0;
          $self->{viewedPromotions} = [];
          my $_etype3 = 0;
          $xfer += $input->readListBegin(\$_etype3, \$_size0);
          for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
          {
            my $elem5 = undef;
            $xfer += $input->readString(\$elem5);
            push(@{$self->{viewedPromotions}},$elem5);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{incomingEmailAddress});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size6 = 0;
          $self->{recentMailedAddresses} = [];
          my $_etype9 = 0;
          $xfer += $input->readListBegin(\$_etype9, \$_size6);
          for (my $_i10 = 0; $_i10 < $_size6; ++$_i10)
          {
            my $elem11 = undef;
            $xfer += $input->readString(\$elem11);
            push(@{$self->{recentMailedAddresses}},$elem11);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{comments});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{dateAgreedToTermsOfService});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{maxReferrals});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{referralCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{refererCode});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^15$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{sentEmailDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^16$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{sentEmailCount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^17$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{dailyEmailLimit});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^18$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{emailOptOutDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^19$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{partnerEmailOptInDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^20$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{preferredLanguage});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^21$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{preferredCountry});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^22$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{clipFullPage});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^23$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{twitterUserName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^24$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{twitterId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^25$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{groupName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^26$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{recognitionLanguage});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^27$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{customerProfileId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^28$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{referralProof});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^29$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{educationalDiscount});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^30$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{businessAddress});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^31$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{hideSponsorBilling});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserAttributes');
  if (defined $self->{defaultLocationName}) {
    $xfer += $output->writeFieldBegin('defaultLocationName', TType::STRING, 1);
    $xfer += $output->writeString($self->{defaultLocationName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{defaultLatitude}) {
    $xfer += $output->writeFieldBegin('defaultLatitude', TType::DOUBLE, 2);
    $xfer += $output->writeDouble($self->{defaultLatitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{defaultLongitude}) {
    $xfer += $output->writeFieldBegin('defaultLongitude', TType::DOUBLE, 3);
    $xfer += $output->writeDouble($self->{defaultLongitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{preactivation}) {
    $xfer += $output->writeFieldBegin('preactivation', TType::BOOL, 4);
    $xfer += $output->writeBool($self->{preactivation});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{viewedPromotions}) {
    $xfer += $output->writeFieldBegin('viewedPromotions', TType::LIST, 5);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{viewedPromotions}}));
      {
        foreach my $iter12 (@{$self->{viewedPromotions}}) 
        {
          $xfer += $output->writeString($iter12);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{incomingEmailAddress}) {
    $xfer += $output->writeFieldBegin('incomingEmailAddress', TType::STRING, 6);
    $xfer += $output->writeString($self->{incomingEmailAddress});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{recentMailedAddresses}) {
    $xfer += $output->writeFieldBegin('recentMailedAddresses', TType::LIST, 7);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{recentMailedAddresses}}));
      {
        foreach my $iter13 (@{$self->{recentMailedAddresses}}) 
        {
          $xfer += $output->writeString($iter13);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{comments}) {
    $xfer += $output->writeFieldBegin('comments', TType::STRING, 9);
    $xfer += $output->writeString($self->{comments});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{dateAgreedToTermsOfService}) {
    $xfer += $output->writeFieldBegin('dateAgreedToTermsOfService', TType::I64, 11);
    $xfer += $output->writeI64($self->{dateAgreedToTermsOfService});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{maxReferrals}) {
    $xfer += $output->writeFieldBegin('maxReferrals', TType::I32, 12);
    $xfer += $output->writeI32($self->{maxReferrals});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{referralCount}) {
    $xfer += $output->writeFieldBegin('referralCount', TType::I32, 13);
    $xfer += $output->writeI32($self->{referralCount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{refererCode}) {
    $xfer += $output->writeFieldBegin('refererCode', TType::STRING, 14);
    $xfer += $output->writeString($self->{refererCode});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sentEmailDate}) {
    $xfer += $output->writeFieldBegin('sentEmailDate', TType::I64, 15);
    $xfer += $output->writeI64($self->{sentEmailDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sentEmailCount}) {
    $xfer += $output->writeFieldBegin('sentEmailCount', TType::I32, 16);
    $xfer += $output->writeI32($self->{sentEmailCount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{dailyEmailLimit}) {
    $xfer += $output->writeFieldBegin('dailyEmailLimit', TType::I32, 17);
    $xfer += $output->writeI32($self->{dailyEmailLimit});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{emailOptOutDate}) {
    $xfer += $output->writeFieldBegin('emailOptOutDate', TType::I64, 18);
    $xfer += $output->writeI64($self->{emailOptOutDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{partnerEmailOptInDate}) {
    $xfer += $output->writeFieldBegin('partnerEmailOptInDate', TType::I64, 19);
    $xfer += $output->writeI64($self->{partnerEmailOptInDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{preferredLanguage}) {
    $xfer += $output->writeFieldBegin('preferredLanguage', TType::STRING, 20);
    $xfer += $output->writeString($self->{preferredLanguage});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{preferredCountry}) {
    $xfer += $output->writeFieldBegin('preferredCountry', TType::STRING, 21);
    $xfer += $output->writeString($self->{preferredCountry});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{clipFullPage}) {
    $xfer += $output->writeFieldBegin('clipFullPage', TType::BOOL, 22);
    $xfer += $output->writeBool($self->{clipFullPage});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{twitterUserName}) {
    $xfer += $output->writeFieldBegin('twitterUserName', TType::STRING, 23);
    $xfer += $output->writeString($self->{twitterUserName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{twitterId}) {
    $xfer += $output->writeFieldBegin('twitterId', TType::STRING, 24);
    $xfer += $output->writeString($self->{twitterId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{groupName}) {
    $xfer += $output->writeFieldBegin('groupName', TType::STRING, 25);
    $xfer += $output->writeString($self->{groupName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{recognitionLanguage}) {
    $xfer += $output->writeFieldBegin('recognitionLanguage', TType::STRING, 26);
    $xfer += $output->writeString($self->{recognitionLanguage});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{customerProfileId}) {
    $xfer += $output->writeFieldBegin('customerProfileId', TType::I64, 27);
    $xfer += $output->writeI64($self->{customerProfileId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{referralProof}) {
    $xfer += $output->writeFieldBegin('referralProof', TType::STRING, 28);
    $xfer += $output->writeString($self->{referralProof});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{educationalDiscount}) {
    $xfer += $output->writeFieldBegin('educationalDiscount', TType::BOOL, 29);
    $xfer += $output->writeBool($self->{educationalDiscount});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{businessAddress}) {
    $xfer += $output->writeFieldBegin('businessAddress', TType::STRING, 30);
    $xfer += $output->writeString($self->{businessAddress});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{hideSponsorBilling}) {
    $xfer += $output->writeFieldBegin('hideSponsorBilling', TType::BOOL, 31);
    $xfer += $output->writeBool($self->{hideSponsorBilling});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Accounting;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Accounting->mk_accessors( qw( uploadLimit uploadLimitEnd uploadLimitNextMonth premiumServiceStatus premiumOrderNumber premiumCommerceService premiumServiceStart premiumServiceSKU lastSuccessfulCharge lastFailedCharge lastFai...

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{uploadLimit} = undef;
  $self->{uploadLimitEnd} = undef;
  $self->{uploadLimitNextMonth} = undef;
  $self->{premiumServiceStatus} = undef;
  $self->{premiumOrderNumber} = undef;
  $self->{premiumCommerceService} = undef;
  $self->{premiumServiceStart} = undef;
  $self->{premiumServiceSKU} = undef;
  $self->{lastSuccessfulCharge} = undef;
  $self->{lastFailedCharge} = undef;
  $self->{lastFailedChargeReason} = undef;
  $self->{nextPaymentDue} = undef;
  $self->{premiumLockUntil} = undef;
  $self->{updated} = undef;
  $self->{premiumSubscriptionNumber} = undef;
  $self->{lastRequestedCharge} = undef;
  $self->{currency} = undef;
  $self->{unitPrice} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{uploadLimit}) {
      $self->{uploadLimit} = $vals->{uploadLimit};
    }
    if (defined $vals->{uploadLimitEnd}) {
      $self->{uploadLimitEnd} = $vals->{uploadLimitEnd};
    }
    if (defined $vals->{uploadLimitNextMonth}) {
      $self->{uploadLimitNextMonth} = $vals->{uploadLimitNextMonth};
    }
    if (defined $vals->{premiumServiceStatus}) {
      $self->{premiumServiceStatus} = $vals->{premiumServiceStatus};
    }
    if (defined $vals->{premiumOrderNumber}) {
      $self->{premiumOrderNumber} = $vals->{premiumOrderNumber};
    }
    if (defined $vals->{premiumCommerceService}) {
      $self->{premiumCommerceService} = $vals->{premiumCommerceService};
    }
    if (defined $vals->{premiumServiceStart}) {
      $self->{premiumServiceStart} = $vals->{premiumServiceStart};
    }
    if (defined $vals->{premiumServiceSKU}) {
      $self->{premiumServiceSKU} = $vals->{premiumServiceSKU};
    }
    if (defined $vals->{lastSuccessfulCharge}) {
      $self->{lastSuccessfulCharge} = $vals->{lastSuccessfulCharge};
    }
    if (defined $vals->{lastFailedCharge}) {
      $self->{lastFailedCharge} = $vals->{lastFailedCharge};
    }
    if (defined $vals->{lastFailedChargeReason}) {
      $self->{lastFailedChargeReason} = $vals->{lastFailedChargeReason};
    }
    if (defined $vals->{nextPaymentDue}) {
      $self->{nextPaymentDue} = $vals->{nextPaymentDue};
    }
    if (defined $vals->{premiumLockUntil}) {
      $self->{premiumLockUntil} = $vals->{premiumLockUntil};
    }
    if (defined $vals->{updated}) {
      $self->{updated} = $vals->{updated};
    }
    if (defined $vals->{premiumSubscriptionNumber}) {
      $self->{premiumSubscriptionNumber} = $vals->{premiumSubscriptionNumber};
    }
    if (defined $vals->{lastRequestedCharge}) {
      $self->{lastRequestedCharge} = $vals->{lastRequestedCharge};
    }
    if (defined $vals->{currency}) {
      $self->{currency} = $vals->{currency};
    }
    if (defined $vals->{unitPrice}) {
      $self->{unitPrice} = $vals->{unitPrice};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Accounting';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{uploadLimit});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{uploadLimitEnd});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{uploadLimitNextMonth});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{premiumServiceStatus});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{premiumOrderNumber});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{premiumCommerceService});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{premiumServiceStart});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{premiumServiceSKU});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{lastSuccessfulCharge});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{lastFailedCharge});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{lastFailedChargeReason});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{nextPaymentDue});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{premiumLockUntil});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{updated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^16$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{premiumSubscriptionNumber});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^17$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{lastRequestedCharge});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^18$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{currency});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^19$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{unitPrice});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Accounting');
  if (defined $self->{uploadLimit}) {
    $xfer += $output->writeFieldBegin('uploadLimit', TType::I64, 1);
    $xfer += $output->writeI64($self->{uploadLimit});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{uploadLimitEnd}) {
    $xfer += $output->writeFieldBegin('uploadLimitEnd', TType::I64, 2);
    $xfer += $output->writeI64($self->{uploadLimitEnd});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{uploadLimitNextMonth}) {
    $xfer += $output->writeFieldBegin('uploadLimitNextMonth', TType::I64, 3);
    $xfer += $output->writeI64($self->{uploadLimitNextMonth});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumServiceStatus}) {
    $xfer += $output->writeFieldBegin('premiumServiceStatus', TType::I32, 4);
    $xfer += $output->writeI32($self->{premiumServiceStatus});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumOrderNumber}) {
    $xfer += $output->writeFieldBegin('premiumOrderNumber', TType::STRING, 5);
    $xfer += $output->writeString($self->{premiumOrderNumber});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumCommerceService}) {
    $xfer += $output->writeFieldBegin('premiumCommerceService', TType::STRING, 6);
    $xfer += $output->writeString($self->{premiumCommerceService});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumServiceStart}) {
    $xfer += $output->writeFieldBegin('premiumServiceStart', TType::I64, 7);
    $xfer += $output->writeI64($self->{premiumServiceStart});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumServiceSKU}) {
    $xfer += $output->writeFieldBegin('premiumServiceSKU', TType::STRING, 8);
    $xfer += $output->writeString($self->{premiumServiceSKU});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{lastSuccessfulCharge}) {
    $xfer += $output->writeFieldBegin('lastSuccessfulCharge', TType::I64, 9);
    $xfer += $output->writeI64($self->{lastSuccessfulCharge});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{lastFailedCharge}) {
    $xfer += $output->writeFieldBegin('lastFailedCharge', TType::I64, 10);
    $xfer += $output->writeI64($self->{lastFailedCharge});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{lastFailedChargeReason}) {
    $xfer += $output->writeFieldBegin('lastFailedChargeReason', TType::STRING, 11);
    $xfer += $output->writeString($self->{lastFailedChargeReason});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{nextPaymentDue}) {
    $xfer += $output->writeFieldBegin('nextPaymentDue', TType::I64, 12);
    $xfer += $output->writeI64($self->{nextPaymentDue});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumLockUntil}) {
    $xfer += $output->writeFieldBegin('premiumLockUntil', TType::I64, 13);
    $xfer += $output->writeI64($self->{premiumLockUntil});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updated}) {
    $xfer += $output->writeFieldBegin('updated', TType::I64, 14);
    $xfer += $output->writeI64($self->{updated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumSubscriptionNumber}) {
    $xfer += $output->writeFieldBegin('premiumSubscriptionNumber', TType::STRING, 16);
    $xfer += $output->writeString($self->{premiumSubscriptionNumber});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{lastRequestedCharge}) {
    $xfer += $output->writeFieldBegin('lastRequestedCharge', TType::I64, 17);
    $xfer += $output->writeI64($self->{lastRequestedCharge});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{currency}) {
    $xfer += $output->writeFieldBegin('currency', TType::STRING, 18);
    $xfer += $output->writeString($self->{currency});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{unitPrice}) {
    $xfer += $output->writeFieldBegin('unitPrice', TType::I32, 19);
    $xfer += $output->writeI32($self->{unitPrice});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::User;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::User->mk_accessors( qw( id username email name timezone privilege created updated deleted active shardId attributes accounting ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{id} = undef;
  $self->{username} = undef;
  $self->{email} = undef;
  $self->{name} = undef;
  $self->{timezone} = undef;
  $self->{privilege} = undef;
  $self->{created} = undef;
  $self->{updated} = undef;
  $self->{deleted} = undef;
  $self->{active} = undef;
  $self->{shardId} = undef;
  $self->{attributes} = undef;
  $self->{accounting} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{id}) {
      $self->{id} = $vals->{id};
    }
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
    if (defined $vals->{email}) {
      $self->{email} = $vals->{email};
    }
    if (defined $vals->{name}) {
      $self->{name} = $vals->{name};
    }
    if (defined $vals->{timezone}) {
      $self->{timezone} = $vals->{timezone};
    }
    if (defined $vals->{privilege}) {
      $self->{privilege} = $vals->{privilege};
    }
    if (defined $vals->{created}) {
      $self->{created} = $vals->{created};
    }
    if (defined $vals->{updated}) {
      $self->{updated} = $vals->{updated};
    }
    if (defined $vals->{deleted}) {
      $self->{deleted} = $vals->{deleted};
    }
    if (defined $vals->{active}) {
      $self->{active} = $vals->{active};
    }
    if (defined $vals->{shardId}) {
      $self->{shardId} = $vals->{shardId};
    }
    if (defined $vals->{attributes}) {
      $self->{attributes} = $vals->{attributes};
    }
    if (defined $vals->{accounting}) {
      $self->{accounting} = $vals->{accounting};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'User';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{id});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{email});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{name});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{timezone});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{privilege});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{created});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{updated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{deleted});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{active});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shardId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^15$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{attributes} = Net::Evernote::EDAMTypes::UserAttributes->new();
        $xfer += $self->{attributes}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^16$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{accounting} = Net::Evernote::EDAMTypes::Accounting->new();
        $xfer += $self->{accounting}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('User');
  if (defined $self->{id}) {
    $xfer += $output->writeFieldBegin('id', TType::I32, 1);
    $xfer += $output->writeI32($self->{id});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 2);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{email}) {
    $xfer += $output->writeFieldBegin('email', TType::STRING, 3);
    $xfer += $output->writeString($self->{email});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{name}) {
    $xfer += $output->writeFieldBegin('name', TType::STRING, 4);
    $xfer += $output->writeString($self->{name});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{timezone}) {
    $xfer += $output->writeFieldBegin('timezone', TType::STRING, 6);
    $xfer += $output->writeString($self->{timezone});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{privilege}) {
    $xfer += $output->writeFieldBegin('privilege', TType::I32, 7);
    $xfer += $output->writeI32($self->{privilege});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{created}) {
    $xfer += $output->writeFieldBegin('created', TType::I64, 9);
    $xfer += $output->writeI64($self->{created});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updated}) {
    $xfer += $output->writeFieldBegin('updated', TType::I64, 10);
    $xfer += $output->writeI64($self->{updated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{deleted}) {
    $xfer += $output->writeFieldBegin('deleted', TType::I64, 11);
    $xfer += $output->writeI64($self->{deleted});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{active}) {
    $xfer += $output->writeFieldBegin('active', TType::BOOL, 13);
    $xfer += $output->writeBool($self->{active});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shardId}) {
    $xfer += $output->writeFieldBegin('shardId', TType::STRING, 14);
    $xfer += $output->writeString($self->{shardId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{attributes}) {
    $xfer += $output->writeFieldBegin('attributes', TType::STRUCT, 15);
    $xfer += $self->{attributes}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{accounting}) {
    $xfer += $output->writeFieldBegin('accounting', TType::STRUCT, 16);
    $xfer += $self->{accounting}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Tag;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Tag->mk_accessors( qw( guid name parentGuid updateSequenceNum ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{name} = undef;
  $self->{parentGuid} = undef;
  $self->{updateSequenceNum} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{name}) {
      $self->{name} = $vals->{name};
    }
    if (defined $vals->{parentGuid}) {
      $self->{parentGuid} = $vals->{parentGuid};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Tag';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{name});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{parentGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Tag');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{name}) {
    $xfer += $output->writeFieldBegin('name', TType::STRING, 2);
    $xfer += $output->writeString($self->{name});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{parentGuid}) {
    $xfer += $output->writeFieldBegin('parentGuid', TType::STRING, 3);
    $xfer += $output->writeString($self->{parentGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 4);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::LazyMap;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::LazyMap->mk_accessors( qw( keysOnly fullMap ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{keysOnly} = undef;
  $self->{fullMap} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{keysOnly}) {
      $self->{keysOnly} = $vals->{keysOnly};
    }
    if (defined $vals->{fullMap}) {
      $self->{fullMap} = $vals->{fullMap};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'LazyMap';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::SET) {
        {
          my $_size14 = 0;
          $self->{keysOnly} = {};
          my $_etype17 = 0;
          $xfer += $input->readSetBegin(\$_etype17, \$_size14);
          for (my $_i18 = 0; $_i18 < $_size14; ++$_i18)
          {
            my $elem19 = undef;
            $xfer += $input->readString(\$elem19);
            $self->{keysOnly}->{$elem19} = 1;
          }
          $xfer += $input->readSetEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::MAP) {
        {
          my $_size20 = 0;
          $self->{fullMap} = {};
          my $_ktype21 = 0;
          my $_vtype22 = 0;
          $xfer += $input->readMapBegin(\$_ktype21, \$_vtype22, \$_size20);
          for (my $_i24 = 0; $_i24 < $_size20; ++$_i24)
          {
            my $key25 = '';
            my $val26 = '';
            $xfer += $input->readString(\$key25);
            $xfer += $input->readString(\$val26);
            $self->{fullMap}->{$key25} = $val26;
          }
          $xfer += $input->readMapEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('LazyMap');
  if (defined $self->{keysOnly}) {
    $xfer += $output->writeFieldBegin('keysOnly', TType::SET, 1);
    {
      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{keysOnly}}));
      {
        foreach my $iter27 (@{$self->{keysOnly}})
        {
          $xfer += $output->writeString($iter27);
        }
      }
      $xfer += $output->writeSetEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{fullMap}) {
    $xfer += $output->writeFieldBegin('fullMap', TType::MAP, 2);
    {
      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{fullMap}}));
      {
        while( my ($kiter28,$viter29) = each %{$self->{fullMap}}) 
        {
          $xfer += $output->writeString($kiter28);
          $xfer += $output->writeString($viter29);
        }
      }
      $xfer += $output->writeMapEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::ResourceAttributes;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::ResourceAttributes->mk_accessors( qw( sourceURL timestamp latitude longitude altitude cameraMake cameraModel clientWillIndex recoType fileName attachment applicationData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{sourceURL} = undef;
  $self->{timestamp} = undef;
  $self->{latitude} = undef;
  $self->{longitude} = undef;
  $self->{altitude} = undef;
  $self->{cameraMake} = undef;
  $self->{cameraModel} = undef;
  $self->{clientWillIndex} = undef;
  $self->{recoType} = undef;
  $self->{fileName} = undef;
  $self->{attachment} = undef;
  $self->{applicationData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{sourceURL}) {
      $self->{sourceURL} = $vals->{sourceURL};
    }
    if (defined $vals->{timestamp}) {
      $self->{timestamp} = $vals->{timestamp};
    }
    if (defined $vals->{latitude}) {
      $self->{latitude} = $vals->{latitude};
    }
    if (defined $vals->{longitude}) {
      $self->{longitude} = $vals->{longitude};
    }
    if (defined $vals->{altitude}) {
      $self->{altitude} = $vals->{altitude};
    }
    if (defined $vals->{cameraMake}) {
      $self->{cameraMake} = $vals->{cameraMake};
    }
    if (defined $vals->{cameraModel}) {
      $self->{cameraModel} = $vals->{cameraModel};
    }
    if (defined $vals->{clientWillIndex}) {
      $self->{clientWillIndex} = $vals->{clientWillIndex};
    }
    if (defined $vals->{recoType}) {
      $self->{recoType} = $vals->{recoType};
    }
    if (defined $vals->{fileName}) {
      $self->{fileName} = $vals->{fileName};
    }
    if (defined $vals->{attachment}) {
      $self->{attachment} = $vals->{attachment};
    }
    if (defined $vals->{applicationData}) {
      $self->{applicationData} = $vals->{applicationData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'ResourceAttributes';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{sourceURL});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{timestamp});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{latitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{longitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{altitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{cameraMake});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{cameraModel});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{clientWillIndex});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{recoType});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{fileName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{attachment});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{applicationData} = Net::Evernote::EDAMTypes::LazyMap->new();
        $xfer += $self->{applicationData}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('ResourceAttributes');
  if (defined $self->{sourceURL}) {
    $xfer += $output->writeFieldBegin('sourceURL', TType::STRING, 1);
    $xfer += $output->writeString($self->{sourceURL});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{timestamp}) {
    $xfer += $output->writeFieldBegin('timestamp', TType::I64, 2);
    $xfer += $output->writeI64($self->{timestamp});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{latitude}) {
    $xfer += $output->writeFieldBegin('latitude', TType::DOUBLE, 3);
    $xfer += $output->writeDouble($self->{latitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{longitude}) {
    $xfer += $output->writeFieldBegin('longitude', TType::DOUBLE, 4);
    $xfer += $output->writeDouble($self->{longitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{altitude}) {
    $xfer += $output->writeFieldBegin('altitude', TType::DOUBLE, 5);
    $xfer += $output->writeDouble($self->{altitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{cameraMake}) {
    $xfer += $output->writeFieldBegin('cameraMake', TType::STRING, 6);
    $xfer += $output->writeString($self->{cameraMake});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{cameraModel}) {
    $xfer += $output->writeFieldBegin('cameraModel', TType::STRING, 7);
    $xfer += $output->writeString($self->{cameraModel});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{clientWillIndex}) {
    $xfer += $output->writeFieldBegin('clientWillIndex', TType::BOOL, 8);
    $xfer += $output->writeBool($self->{clientWillIndex});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{recoType}) {
    $xfer += $output->writeFieldBegin('recoType', TType::STRING, 9);
    $xfer += $output->writeString($self->{recoType});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{fileName}) {
    $xfer += $output->writeFieldBegin('fileName', TType::STRING, 10);
    $xfer += $output->writeString($self->{fileName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{attachment}) {
    $xfer += $output->writeFieldBegin('attachment', TType::BOOL, 11);
    $xfer += $output->writeBool($self->{attachment});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{applicationData}) {
    $xfer += $output->writeFieldBegin('applicationData', TType::STRUCT, 12);
    $xfer += $self->{applicationData}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Resource;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Resource->mk_accessors( qw( guid noteGuid data mime width height duration active recognition attributes updateSequenceNum alternateData ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{noteGuid} = undef;
  $self->{data} = undef;
  $self->{mime} = undef;
  $self->{width} = undef;
  $self->{height} = undef;
  $self->{duration} = undef;
  $self->{active} = undef;
  $self->{recognition} = undef;
  $self->{attributes} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{alternateData} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{noteGuid}) {
      $self->{noteGuid} = $vals->{noteGuid};
    }
    if (defined $vals->{data}) {
      $self->{data} = $vals->{data};
    }
    if (defined $vals->{mime}) {
      $self->{mime} = $vals->{mime};
    }
    if (defined $vals->{width}) {
      $self->{width} = $vals->{width};
    }
    if (defined $vals->{height}) {
      $self->{height} = $vals->{height};
    }
    if (defined $vals->{duration}) {
      $self->{duration} = $vals->{duration};
    }
    if (defined $vals->{active}) {
      $self->{active} = $vals->{active};
    }
    if (defined $vals->{recognition}) {
      $self->{recognition} = $vals->{recognition};
    }
    if (defined $vals->{attributes}) {
      $self->{attributes} = $vals->{attributes};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{alternateData}) {
      $self->{alternateData} = $vals->{alternateData};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Resource';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{data} = Net::Evernote::EDAMTypes::Data->new();
        $xfer += $self->{data}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{mime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{width});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{height});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{duration});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{active});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{recognition} = Net::Evernote::EDAMTypes::Data->new();
        $xfer += $self->{recognition}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{attributes} = Net::Evernote::EDAMTypes::ResourceAttributes->new();
        $xfer += $self->{attributes}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{alternateData} = Net::Evernote::EDAMTypes::Data->new();
        $xfer += $self->{alternateData}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Resource');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteGuid}) {
    $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
    $xfer += $output->writeString($self->{noteGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{data}) {
    $xfer += $output->writeFieldBegin('data', TType::STRUCT, 3);
    $xfer += $self->{data}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{mime}) {
    $xfer += $output->writeFieldBegin('mime', TType::STRING, 4);
    $xfer += $output->writeString($self->{mime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{width}) {
    $xfer += $output->writeFieldBegin('width', TType::I16, 5);
    $xfer += $output->writeI16($self->{width});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{height}) {
    $xfer += $output->writeFieldBegin('height', TType::I16, 6);
    $xfer += $output->writeI16($self->{height});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{duration}) {
    $xfer += $output->writeFieldBegin('duration', TType::I16, 7);
    $xfer += $output->writeI16($self->{duration});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{active}) {
    $xfer += $output->writeFieldBegin('active', TType::BOOL, 8);
    $xfer += $output->writeBool($self->{active});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{recognition}) {
    $xfer += $output->writeFieldBegin('recognition', TType::STRUCT, 9);
    $xfer += $self->{recognition}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{attributes}) {
    $xfer += $output->writeFieldBegin('attributes', TType::STRUCT, 11);
    $xfer += $self->{attributes}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 12);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{alternateData}) {
    $xfer += $output->writeFieldBegin('alternateData', TType::STRUCT, 13);
    $xfer += $self->{alternateData}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::NoteAttributes;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::NoteAttributes->mk_accessors( qw( subjectDate latitude longitude altitude author source sourceURL sourceApplication shareDate placeName contentClass applicationData lastEditedBy ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{subjectDate} = undef;
  $self->{latitude} = undef;
  $self->{longitude} = undef;
  $self->{altitude} = undef;
  $self->{author} = undef;
  $self->{source} = undef;
  $self->{sourceURL} = undef;
  $self->{sourceApplication} = undef;
  $self->{shareDate} = undef;
  $self->{placeName} = undef;
  $self->{contentClass} = undef;
  $self->{applicationData} = undef;
  $self->{lastEditedBy} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{subjectDate}) {
      $self->{subjectDate} = $vals->{subjectDate};
    }
    if (defined $vals->{latitude}) {
      $self->{latitude} = $vals->{latitude};
    }
    if (defined $vals->{longitude}) {
      $self->{longitude} = $vals->{longitude};
    }
    if (defined $vals->{altitude}) {
      $self->{altitude} = $vals->{altitude};
    }
    if (defined $vals->{author}) {
      $self->{author} = $vals->{author};
    }
    if (defined $vals->{source}) {
      $self->{source} = $vals->{source};
    }
    if (defined $vals->{sourceURL}) {
      $self->{sourceURL} = $vals->{sourceURL};
    }
    if (defined $vals->{sourceApplication}) {
      $self->{sourceApplication} = $vals->{sourceApplication};
    }
    if (defined $vals->{shareDate}) {
      $self->{shareDate} = $vals->{shareDate};
    }
    if (defined $vals->{placeName}) {
      $self->{placeName} = $vals->{placeName};
    }
    if (defined $vals->{contentClass}) {
      $self->{contentClass} = $vals->{contentClass};
    }
    if (defined $vals->{applicationData}) {
      $self->{applicationData} = $vals->{applicationData};
    }
    if (defined $vals->{lastEditedBy}) {
      $self->{lastEditedBy} = $vals->{lastEditedBy};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'NoteAttributes';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{subjectDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{latitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{longitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{altitude});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{author});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{source});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^15$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{sourceURL});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^16$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{sourceApplication});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^17$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{shareDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^21$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{placeName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^22$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{contentClass});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^23$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{applicationData} = Net::Evernote::EDAMTypes::LazyMap->new();
        $xfer += $self->{applicationData}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^24$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{lastEditedBy});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('NoteAttributes');
  if (defined $self->{subjectDate}) {
    $xfer += $output->writeFieldBegin('subjectDate', TType::I64, 1);
    $xfer += $output->writeI64($self->{subjectDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{latitude}) {
    $xfer += $output->writeFieldBegin('latitude', TType::DOUBLE, 10);
    $xfer += $output->writeDouble($self->{latitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{longitude}) {
    $xfer += $output->writeFieldBegin('longitude', TType::DOUBLE, 11);
    $xfer += $output->writeDouble($self->{longitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{altitude}) {
    $xfer += $output->writeFieldBegin('altitude', TType::DOUBLE, 12);
    $xfer += $output->writeDouble($self->{altitude});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{author}) {
    $xfer += $output->writeFieldBegin('author', TType::STRING, 13);
    $xfer += $output->writeString($self->{author});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{source}) {
    $xfer += $output->writeFieldBegin('source', TType::STRING, 14);
    $xfer += $output->writeString($self->{source});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sourceURL}) {
    $xfer += $output->writeFieldBegin('sourceURL', TType::STRING, 15);
    $xfer += $output->writeString($self->{sourceURL});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sourceApplication}) {
    $xfer += $output->writeFieldBegin('sourceApplication', TType::STRING, 16);
    $xfer += $output->writeString($self->{sourceApplication});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shareDate}) {
    $xfer += $output->writeFieldBegin('shareDate', TType::I64, 17);
    $xfer += $output->writeI64($self->{shareDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{placeName}) {
    $xfer += $output->writeFieldBegin('placeName', TType::STRING, 21);
    $xfer += $output->writeString($self->{placeName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{contentClass}) {
    $xfer += $output->writeFieldBegin('contentClass', TType::STRING, 22);
    $xfer += $output->writeString($self->{contentClass});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{applicationData}) {
    $xfer += $output->writeFieldBegin('applicationData', TType::STRUCT, 23);
    $xfer += $self->{applicationData}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{lastEditedBy}) {
    $xfer += $output->writeFieldBegin('lastEditedBy', TType::STRING, 24);
    $xfer += $output->writeString($self->{lastEditedBy});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Note;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Note->mk_accessors( qw( guid title content contentHash contentLength created updated deleted active updateSequenceNum notebookGuid tagGuids resources attributes tagNames ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{title} = undef;
  $self->{content} = undef;
  $self->{contentHash} = undef;
  $self->{contentLength} = undef;
  $self->{created} = undef;
  $self->{updated} = undef;
  $self->{deleted} = undef;
  $self->{active} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{notebookGuid} = undef;
  $self->{tagGuids} = undef;
  $self->{resources} = undef;
  $self->{attributes} = undef;
  $self->{tagNames} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{title}) {
      $self->{title} = $vals->{title};
    }
    if (defined $vals->{content}) {
      $self->{content} = $vals->{content};
    }
    if (defined $vals->{contentHash}) {
      $self->{contentHash} = $vals->{contentHash};
    }
    if (defined $vals->{contentLength}) {
      $self->{contentLength} = $vals->{contentLength};
    }
    if (defined $vals->{created}) {
      $self->{created} = $vals->{created};
    }
    if (defined $vals->{updated}) {
      $self->{updated} = $vals->{updated};
    }
    if (defined $vals->{deleted}) {
      $self->{deleted} = $vals->{deleted};
    }
    if (defined $vals->{active}) {
      $self->{active} = $vals->{active};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
    if (defined $vals->{tagGuids}) {
      $self->{tagGuids} = $vals->{tagGuids};
    }
    if (defined $vals->{resources}) {
      $self->{resources} = $vals->{resources};
    }
    if (defined $vals->{attributes}) {
      $self->{attributes} = $vals->{attributes};
    }
    if (defined $vals->{tagNames}) {
      $self->{tagNames} = $vals->{tagNames};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Note';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{title});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{content});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{contentHash});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{contentLength});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{created});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{updated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{deleted});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{active});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size30 = 0;
          $self->{tagGuids} = [];
          my $_etype33 = 0;
          $xfer += $input->readListBegin(\$_etype33, \$_size30);
          for (my $_i34 = 0; $_i34 < $_size30; ++$_i34)
          {
            my $elem35 = undef;
            $xfer += $input->readString(\$elem35);
            push(@{$self->{tagGuids}},$elem35);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size36 = 0;
          $self->{resources} = [];
          my $_etype39 = 0;
          $xfer += $input->readListBegin(\$_etype39, \$_size36);
          for (my $_i40 = 0; $_i40 < $_size36; ++$_i40)
          {
            my $elem41 = undef;
            $elem41 = Net::Evernote::EDAMTypes::Resource->new();
            $xfer += $elem41->read($input);
            push(@{$self->{resources}},$elem41);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{attributes} = Net::Evernote::EDAMTypes::NoteAttributes->new();
        $xfer += $self->{attributes}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^15$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size42 = 0;
          $self->{tagNames} = [];
          my $_etype45 = 0;
          $xfer += $input->readListBegin(\$_etype45, \$_size42);
          for (my $_i46 = 0; $_i46 < $_size42; ++$_i46)
          {
            my $elem47 = undef;
            $xfer += $input->readString(\$elem47);
            push(@{$self->{tagNames}},$elem47);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Note');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{title}) {
    $xfer += $output->writeFieldBegin('title', TType::STRING, 2);
    $xfer += $output->writeString($self->{title});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{content}) {
    $xfer += $output->writeFieldBegin('content', TType::STRING, 3);
    $xfer += $output->writeString($self->{content});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{contentHash}) {
    $xfer += $output->writeFieldBegin('contentHash', TType::STRING, 4);
    $xfer += $output->writeString($self->{contentHash});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{contentLength}) {
    $xfer += $output->writeFieldBegin('contentLength', TType::I32, 5);
    $xfer += $output->writeI32($self->{contentLength});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{created}) {
    $xfer += $output->writeFieldBegin('created', TType::I64, 6);
    $xfer += $output->writeI64($self->{created});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updated}) {
    $xfer += $output->writeFieldBegin('updated', TType::I64, 7);
    $xfer += $output->writeI64($self->{updated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{deleted}) {
    $xfer += $output->writeFieldBegin('deleted', TType::I64, 8);
    $xfer += $output->writeI64($self->{deleted});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{active}) {
    $xfer += $output->writeFieldBegin('active', TType::BOOL, 9);
    $xfer += $output->writeBool($self->{active});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 10);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 11);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tagGuids}) {
    $xfer += $output->writeFieldBegin('tagGuids', TType::LIST, 12);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagGuids}}));
      {
        foreach my $iter48 (@{$self->{tagGuids}}) 
        {
          $xfer += $output->writeString($iter48);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{resources}) {
    $xfer += $output->writeFieldBegin('resources', TType::LIST, 13);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{resources}}));
      {
        foreach my $iter49 (@{$self->{resources}}) 
        {
          $xfer += ${iter49}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{attributes}) {
    $xfer += $output->writeFieldBegin('attributes', TType::STRUCT, 14);
    $xfer += $self->{attributes}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{tagNames}) {
    $xfer += $output->writeFieldBegin('tagNames', TType::LIST, 15);
    {
      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagNames}}));
      {
        foreach my $iter50 (@{$self->{tagNames}}) 
        {
          $xfer += $output->writeString($iter50);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Publishing;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Publishing->mk_accessors( qw( uri order ascending publicDescription ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{uri} = undef;
  $self->{order} = undef;
  $self->{ascending} = undef;
  $self->{publicDescription} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{uri}) {
      $self->{uri} = $vals->{uri};
    }
    if (defined $vals->{order}) {
      $self->{order} = $vals->{order};
    }
    if (defined $vals->{ascending}) {
      $self->{ascending} = $vals->{ascending};
    }
    if (defined $vals->{publicDescription}) {
      $self->{publicDescription} = $vals->{publicDescription};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Publishing';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{uri});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{order});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{ascending});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{publicDescription});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Publishing');
  if (defined $self->{uri}) {
    $xfer += $output->writeFieldBegin('uri', TType::STRING, 1);
    $xfer += $output->writeString($self->{uri});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{order}) {
    $xfer += $output->writeFieldBegin('order', TType::I32, 2);
    $xfer += $output->writeI32($self->{order});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{ascending}) {
    $xfer += $output->writeFieldBegin('ascending', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{ascending});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{publicDescription}) {
    $xfer += $output->writeFieldBegin('publicDescription', TType::STRING, 4);
    $xfer += $output->writeString($self->{publicDescription});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::SavedSearch;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::SavedSearch->mk_accessors( qw( guid name query format updateSequenceNum ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{name} = undef;
  $self->{query} = undef;
  $self->{format} = undef;
  $self->{updateSequenceNum} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{name}) {
      $self->{name} = $vals->{name};
    }
    if (defined $vals->{query}) {
      $self->{query} = $vals->{query};
    }
    if (defined $vals->{format}) {
      $self->{format} = $vals->{format};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'SavedSearch';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{name});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{query});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{format});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('SavedSearch');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{name}) {
    $xfer += $output->writeFieldBegin('name', TType::STRING, 2);
    $xfer += $output->writeString($self->{name});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{query}) {
    $xfer += $output->writeFieldBegin('query', TType::STRING, 3);
    $xfer += $output->writeString($self->{query});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{format}) {
    $xfer += $output->writeFieldBegin('format', TType::I32, 4);
    $xfer += $output->writeI32($self->{format});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 5);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Ad;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Ad->mk_accessors( qw( id width height advertiserName imageUrl destinationUrl displaySeconds score image imageMime html displayFrequency openInTrunk ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{id} = undef;
  $self->{width} = undef;
  $self->{height} = undef;
  $self->{advertiserName} = undef;
  $self->{imageUrl} = undef;
  $self->{destinationUrl} = undef;
  $self->{displaySeconds} = undef;
  $self->{score} = undef;
  $self->{image} = undef;
  $self->{imageMime} = undef;
  $self->{html} = undef;
  $self->{displayFrequency} = undef;
  $self->{openInTrunk} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{id}) {
      $self->{id} = $vals->{id};
    }
    if (defined $vals->{width}) {
      $self->{width} = $vals->{width};
    }
    if (defined $vals->{height}) {
      $self->{height} = $vals->{height};
    }
    if (defined $vals->{advertiserName}) {
      $self->{advertiserName} = $vals->{advertiserName};
    }
    if (defined $vals->{imageUrl}) {
      $self->{imageUrl} = $vals->{imageUrl};
    }
    if (defined $vals->{destinationUrl}) {
      $self->{destinationUrl} = $vals->{destinationUrl};
    }
    if (defined $vals->{displaySeconds}) {
      $self->{displaySeconds} = $vals->{displaySeconds};
    }
    if (defined $vals->{score}) {
      $self->{score} = $vals->{score};
    }
    if (defined $vals->{image}) {
      $self->{image} = $vals->{image};
    }
    if (defined $vals->{imageMime}) {
      $self->{imageMime} = $vals->{imageMime};
    }
    if (defined $vals->{html}) {
      $self->{html} = $vals->{html};
    }
    if (defined $vals->{displayFrequency}) {
      $self->{displayFrequency} = $vals->{displayFrequency};
    }
    if (defined $vals->{openInTrunk}) {
      $self->{openInTrunk} = $vals->{openInTrunk};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Ad';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{id});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{width});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{height});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{advertiserName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{imageUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{destinationUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{displaySeconds});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{score});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{image});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{imageMime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{html});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::DOUBLE) {
        $xfer += $input->readDouble(\$self->{displayFrequency});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{openInTrunk});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Ad');
  if (defined $self->{id}) {
    $xfer += $output->writeFieldBegin('id', TType::I32, 1);
    $xfer += $output->writeI32($self->{id});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{width}) {
    $xfer += $output->writeFieldBegin('width', TType::I16, 2);
    $xfer += $output->writeI16($self->{width});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{height}) {
    $xfer += $output->writeFieldBegin('height', TType::I16, 3);
    $xfer += $output->writeI16($self->{height});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{advertiserName}) {
    $xfer += $output->writeFieldBegin('advertiserName', TType::STRING, 4);
    $xfer += $output->writeString($self->{advertiserName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{imageUrl}) {
    $xfer += $output->writeFieldBegin('imageUrl', TType::STRING, 5);
    $xfer += $output->writeString($self->{imageUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{destinationUrl}) {
    $xfer += $output->writeFieldBegin('destinationUrl', TType::STRING, 6);
    $xfer += $output->writeString($self->{destinationUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{displaySeconds}) {
    $xfer += $output->writeFieldBegin('displaySeconds', TType::I16, 7);
    $xfer += $output->writeI16($self->{displaySeconds});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{score}) {
    $xfer += $output->writeFieldBegin('score', TType::DOUBLE, 8);
    $xfer += $output->writeDouble($self->{score});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{image}) {
    $xfer += $output->writeFieldBegin('image', TType::STRING, 9);
    $xfer += $output->writeString($self->{image});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{imageMime}) {
    $xfer += $output->writeFieldBegin('imageMime', TType::STRING, 10);
    $xfer += $output->writeString($self->{imageMime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{html}) {
    $xfer += $output->writeFieldBegin('html', TType::STRING, 11);
    $xfer += $output->writeString($self->{html});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{displayFrequency}) {
    $xfer += $output->writeFieldBegin('displayFrequency', TType::DOUBLE, 12);
    $xfer += $output->writeDouble($self->{displayFrequency});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{openInTrunk}) {
    $xfer += $output->writeFieldBegin('openInTrunk', TType::BOOL, 13);
    $xfer += $output->writeBool($self->{openInTrunk});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::SharedNotebook;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::SharedNotebook->mk_accessors( qw( id userId notebookGuid email notebookModifiable requireLogin serviceCreated serviceUpdated shareKey username ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{id} = undef;
  $self->{userId} = undef;
  $self->{notebookGuid} = undef;
  $self->{email} = undef;
  $self->{notebookModifiable} = undef;
  $self->{requireLogin} = undef;
  $self->{serviceCreated} = undef;
  $self->{serviceUpdated} = undef;
  $self->{shareKey} = undef;
  $self->{username} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{id}) {
      $self->{id} = $vals->{id};
    }
    if (defined $vals->{userId}) {
      $self->{userId} = $vals->{userId};
    }
    if (defined $vals->{notebookGuid}) {
      $self->{notebookGuid} = $vals->{notebookGuid};
    }
    if (defined $vals->{email}) {
      $self->{email} = $vals->{email};
    }
    if (defined $vals->{notebookModifiable}) {
      $self->{notebookModifiable} = $vals->{notebookModifiable};
    }
    if (defined $vals->{requireLogin}) {
      $self->{requireLogin} = $vals->{requireLogin};
    }
    if (defined $vals->{serviceCreated}) {
      $self->{serviceCreated} = $vals->{serviceCreated};
    }
    if (defined $vals->{serviceUpdated}) {
      $self->{serviceUpdated} = $vals->{serviceUpdated};
    }
    if (defined $vals->{shareKey}) {
      $self->{shareKey} = $vals->{shareKey};
    }
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'SharedNotebook';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{id});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{userId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{notebookGuid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{email});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{notebookModifiable});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{requireLogin});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{serviceCreated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{serviceUpdated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shareKey});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('SharedNotebook');
  if (defined $self->{id}) {
    $xfer += $output->writeFieldBegin('id', TType::I64, 1);
    $xfer += $output->writeI64($self->{id});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userId}) {
    $xfer += $output->writeFieldBegin('userId', TType::I32, 2);
    $xfer += $output->writeI32($self->{userId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookGuid}) {
    $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 3);
    $xfer += $output->writeString($self->{notebookGuid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{email}) {
    $xfer += $output->writeFieldBegin('email', TType::STRING, 4);
    $xfer += $output->writeString($self->{email});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notebookModifiable}) {
    $xfer += $output->writeFieldBegin('notebookModifiable', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{notebookModifiable});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{requireLogin}) {
    $xfer += $output->writeFieldBegin('requireLogin', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{requireLogin});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{serviceCreated}) {
    $xfer += $output->writeFieldBegin('serviceCreated', TType::I64, 7);
    $xfer += $output->writeI64($self->{serviceCreated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shareKey}) {
    $xfer += $output->writeFieldBegin('shareKey', TType::STRING, 8);
    $xfer += $output->writeString($self->{shareKey});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 9);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{serviceUpdated}) {
    $xfer += $output->writeFieldBegin('serviceUpdated', TType::I64, 10);
    $xfer += $output->writeI64($self->{serviceUpdated});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::Notebook;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::Notebook->mk_accessors( qw( guid name updateSequenceNum defaultNotebook serviceCreated serviceUpdated publishing published stack sharedNotebookIds sharedNotebooks ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{guid} = undef;
  $self->{name} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{defaultNotebook} = undef;
  $self->{serviceCreated} = undef;
  $self->{serviceUpdated} = undef;
  $self->{publishing} = undef;
  $self->{published} = undef;
  $self->{stack} = undef;
  $self->{sharedNotebookIds} = undef;
  $self->{sharedNotebooks} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{name}) {
      $self->{name} = $vals->{name};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{defaultNotebook}) {
      $self->{defaultNotebook} = $vals->{defaultNotebook};
    }
    if (defined $vals->{serviceCreated}) {
      $self->{serviceCreated} = $vals->{serviceCreated};
    }
    if (defined $vals->{serviceUpdated}) {
      $self->{serviceUpdated} = $vals->{serviceUpdated};
    }
    if (defined $vals->{publishing}) {
      $self->{publishing} = $vals->{publishing};
    }
    if (defined $vals->{published}) {
      $self->{published} = $vals->{published};
    }
    if (defined $vals->{stack}) {
      $self->{stack} = $vals->{stack};
    }
    if (defined $vals->{sharedNotebookIds}) {
      $self->{sharedNotebookIds} = $vals->{sharedNotebookIds};
    }
    if (defined $vals->{sharedNotebooks}) {
      $self->{sharedNotebooks} = $vals->{sharedNotebooks};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'Notebook';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{name});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{defaultNotebook});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{serviceCreated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{serviceUpdated});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{publishing} = Net::Evernote::EDAMTypes::Publishing->new();
        $xfer += $self->{publishing}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{published});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^12$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{stack});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^13$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size51 = 0;
          $self->{sharedNotebookIds} = [];
          my $_etype54 = 0;
          $xfer += $input->readListBegin(\$_etype54, \$_size51);
          for (my $_i55 = 0; $_i55 < $_size51; ++$_i55)
          {
            my $elem56 = undef;
            $xfer += $input->readI64(\$elem56);
            push(@{$self->{sharedNotebookIds}},$elem56);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^14$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size57 = 0;
          $self->{sharedNotebooks} = [];
          my $_etype60 = 0;
          $xfer += $input->readListBegin(\$_etype60, \$_size57);
          for (my $_i61 = 0; $_i61 < $_size57; ++$_i61)
          {
            my $elem62 = undef;
            $elem62 = Net::Evernote::EDAMTypes::SharedNotebook->new();
            $xfer += $elem62->read($input);
            push(@{$self->{sharedNotebooks}},$elem62);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('Notebook');
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{name}) {
    $xfer += $output->writeFieldBegin('name', TType::STRING, 2);
    $xfer += $output->writeString($self->{name});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 5);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{defaultNotebook}) {
    $xfer += $output->writeFieldBegin('defaultNotebook', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{defaultNotebook});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{serviceCreated}) {
    $xfer += $output->writeFieldBegin('serviceCreated', TType::I64, 7);
    $xfer += $output->writeI64($self->{serviceCreated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{serviceUpdated}) {
    $xfer += $output->writeFieldBegin('serviceUpdated', TType::I64, 8);
    $xfer += $output->writeI64($self->{serviceUpdated});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{publishing}) {
    $xfer += $output->writeFieldBegin('publishing', TType::STRUCT, 10);
    $xfer += $self->{publishing}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{published}) {
    $xfer += $output->writeFieldBegin('published', TType::BOOL, 11);
    $xfer += $output->writeBool($self->{published});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{stack}) {
    $xfer += $output->writeFieldBegin('stack', TType::STRING, 12);
    $xfer += $output->writeString($self->{stack});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sharedNotebookIds}) {
    $xfer += $output->writeFieldBegin('sharedNotebookIds', TType::LIST, 13);
    {
      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{sharedNotebookIds}}));
      {
        foreach my $iter63 (@{$self->{sharedNotebookIds}}) 
        {
          $xfer += $output->writeI64($iter63);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sharedNotebooks}) {
    $xfer += $output->writeFieldBegin('sharedNotebooks', TType::LIST, 14);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{sharedNotebooks}}));
      {
        foreach my $iter64 (@{$self->{sharedNotebooks}}) 
        {
          $xfer += ${iter64}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMTypes::LinkedNotebook;
use base qw(Class::Accessor);
Net::Evernote::EDAMTypes::LinkedNotebook->mk_accessors( qw( shareName username shardId shareKey uri guid updateSequenceNum noteStoreUrl webApiUrlPrefix ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{shareName} = undef;
  $self->{username} = undef;
  $self->{shardId} = undef;
  $self->{shareKey} = undef;
  $self->{uri} = undef;
  $self->{guid} = undef;
  $self->{updateSequenceNum} = undef;
  $self->{noteStoreUrl} = undef;
  $self->{webApiUrlPrefix} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{shareName}) {
      $self->{shareName} = $vals->{shareName};
    }
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
    if (defined $vals->{shardId}) {
      $self->{shardId} = $vals->{shardId};
    }
    if (defined $vals->{shareKey}) {
      $self->{shareKey} = $vals->{shareKey};
    }
    if (defined $vals->{uri}) {
      $self->{uri} = $vals->{uri};
    }
    if (defined $vals->{guid}) {
      $self->{guid} = $vals->{guid};
    }
    if (defined $vals->{updateSequenceNum}) {
      $self->{updateSequenceNum} = $vals->{updateSequenceNum};
    }
    if (defined $vals->{noteStoreUrl}) {
      $self->{noteStoreUrl} = $vals->{noteStoreUrl};
    }
    if (defined $vals->{webApiUrlPrefix}) {
      $self->{webApiUrlPrefix} = $vals->{webApiUrlPrefix};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'LinkedNotebook';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shareName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shardId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shareKey});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{uri});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{guid});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{updateSequenceNum});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteStoreUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{webApiUrlPrefix});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('LinkedNotebook');
  if (defined $self->{shareName}) {
    $xfer += $output->writeFieldBegin('shareName', TType::STRING, 2);
    $xfer += $output->writeString($self->{shareName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 3);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shardId}) {
    $xfer += $output->writeFieldBegin('shardId', TType::STRING, 4);
    $xfer += $output->writeString($self->{shardId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shareKey}) {
    $xfer += $output->writeFieldBegin('shareKey', TType::STRING, 5);
    $xfer += $output->writeString($self->{shareKey});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{uri}) {
    $xfer += $output->writeFieldBegin('uri', TType::STRING, 6);
    $xfer += $output->writeString($self->{uri});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{guid}) {
    $xfer += $output->writeFieldBegin('guid', TType::STRING, 7);
    $xfer += $output->writeString($self->{guid});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{updateSequenceNum}) {
    $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 8);
    $xfer += $output->writeI32($self->{updateSequenceNum});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteStoreUrl}) {
    $xfer += $output->writeFieldBegin('noteStoreUrl', TType::STRING, 9);
    $xfer += $output->writeString($self->{noteStoreUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{webApiUrlPrefix}) {
    $xfer += $output->writeFieldBegin('webApiUrlPrefix', TType::STRING, 10);
    $xfer += $output->writeString($self->{webApiUrlPrefix});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

1;

lib/Net/Evernote/EDAMUserStore/Constants.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
package Net::Evernote::EDAMUserStore::Constants;
require 5.6.0;
use strict;
use warnings;
use Thrift;


use constant EDAM_VERSION_MAJOR => 1;

use constant EDAM_VERSION_MINOR => 21;

1;

lib/Net/Evernote/EDAMUserStore/Types.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

package Net::Evernote::EDAMUserStore::SponsoredGroupRole;
use constant GROUP_MEMBER => 1;
use constant GROUP_ADMIN => 2;
use constant GROUP_OWNER => 3;
package Net::Evernote::EDAMUserStore::PublicUserInfo;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::PublicUserInfo->mk_accessors( qw( userId shardId privilege username noteStoreUrl ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{userId} = undef;
  $self->{shardId} = undef;
  $self->{privilege} = undef;
  $self->{username} = undef;
  $self->{noteStoreUrl} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{userId}) {
      $self->{userId} = $vals->{userId};
    }
    if (defined $vals->{shardId}) {
      $self->{shardId} = $vals->{shardId};
    }
    if (defined $vals->{privilege}) {
      $self->{privilege} = $vals->{privilege};
    }
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
    if (defined $vals->{noteStoreUrl}) {
      $self->{noteStoreUrl} = $vals->{noteStoreUrl};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'PublicUserInfo';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{userId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{shardId});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{privilege});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteStoreUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('PublicUserInfo');
  if (defined $self->{userId}) {
    $xfer += $output->writeFieldBegin('userId', TType::I32, 1);
    $xfer += $output->writeI32($self->{userId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{shardId}) {
    $xfer += $output->writeFieldBegin('shardId', TType::STRING, 2);
    $xfer += $output->writeString($self->{shardId});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{privilege}) {
    $xfer += $output->writeFieldBegin('privilege', TType::I32, 3);
    $xfer += $output->writeI32($self->{privilege});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 4);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteStoreUrl}) {
    $xfer += $output->writeFieldBegin('noteStoreUrl', TType::STRING, 5);
    $xfer += $output->writeString($self->{noteStoreUrl});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::PremiumInfo;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::PremiumInfo->mk_accessors( qw( currentTime premium premiumRecurring premiumExpirationDate premiumExtendable premiumPending premiumCancellationPending canPurchaseUploadAllowance sponsoredGroupName sponsoredGroupRole ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{currentTime} = undef;
  $self->{premium} = undef;
  $self->{premiumRecurring} = undef;
  $self->{premiumExpirationDate} = undef;
  $self->{premiumExtendable} = undef;
  $self->{premiumPending} = undef;
  $self->{premiumCancellationPending} = undef;
  $self->{canPurchaseUploadAllowance} = undef;
  $self->{sponsoredGroupName} = undef;
  $self->{sponsoredGroupRole} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{currentTime}) {
      $self->{currentTime} = $vals->{currentTime};
    }
    if (defined $vals->{premium}) {
      $self->{premium} = $vals->{premium};
    }
    if (defined $vals->{premiumRecurring}) {
      $self->{premiumRecurring} = $vals->{premiumRecurring};
    }
    if (defined $vals->{premiumExpirationDate}) {
      $self->{premiumExpirationDate} = $vals->{premiumExpirationDate};
    }
    if (defined $vals->{premiumExtendable}) {
      $self->{premiumExtendable} = $vals->{premiumExtendable};
    }
    if (defined $vals->{premiumPending}) {
      $self->{premiumPending} = $vals->{premiumPending};
    }
    if (defined $vals->{premiumCancellationPending}) {
      $self->{premiumCancellationPending} = $vals->{premiumCancellationPending};
    }
    if (defined $vals->{canPurchaseUploadAllowance}) {
      $self->{canPurchaseUploadAllowance} = $vals->{canPurchaseUploadAllowance};
    }
    if (defined $vals->{sponsoredGroupName}) {
      $self->{sponsoredGroupName} = $vals->{sponsoredGroupName};
    }
    if (defined $vals->{sponsoredGroupRole}) {
      $self->{sponsoredGroupRole} = $vals->{sponsoredGroupRole};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'PremiumInfo';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{currentTime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{premium});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{premiumRecurring});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{premiumExpirationDate});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{premiumExtendable});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{premiumPending});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{premiumCancellationPending});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{canPurchaseUploadAllowance});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{sponsoredGroupName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::I32) {
        $xfer += $input->readI32(\$self->{sponsoredGroupRole});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('PremiumInfo');
  if (defined $self->{currentTime}) {
    $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
    $xfer += $output->writeI64($self->{currentTime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premium}) {
    $xfer += $output->writeFieldBegin('premium', TType::BOOL, 2);
    $xfer += $output->writeBool($self->{premium});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumRecurring}) {
    $xfer += $output->writeFieldBegin('premiumRecurring', TType::BOOL, 3);
    $xfer += $output->writeBool($self->{premiumRecurring});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumExpirationDate}) {
    $xfer += $output->writeFieldBegin('premiumExpirationDate', TType::I64, 4);
    $xfer += $output->writeI64($self->{premiumExpirationDate});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumExtendable}) {
    $xfer += $output->writeFieldBegin('premiumExtendable', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{premiumExtendable});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumPending}) {
    $xfer += $output->writeFieldBegin('premiumPending', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{premiumPending});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{premiumCancellationPending}) {
    $xfer += $output->writeFieldBegin('premiumCancellationPending', TType::BOOL, 7);
    $xfer += $output->writeBool($self->{premiumCancellationPending});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{canPurchaseUploadAllowance}) {
    $xfer += $output->writeFieldBegin('canPurchaseUploadAllowance', TType::BOOL, 8);
    $xfer += $output->writeBool($self->{canPurchaseUploadAllowance});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sponsoredGroupName}) {
    $xfer += $output->writeFieldBegin('sponsoredGroupName', TType::STRING, 9);
    $xfer += $output->writeString($self->{sponsoredGroupName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{sponsoredGroupRole}) {
    $xfer += $output->writeFieldBegin('sponsoredGroupRole', TType::I32, 10);
    $xfer += $output->writeI32($self->{sponsoredGroupRole});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::AuthenticationResult;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::AuthenticationResult->mk_accessors( qw( currentTime authenticationToken expiration user publicUserInfo noteStoreUrl webApiUrlPrefix ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{currentTime} = undef;
  $self->{authenticationToken} = undef;
  $self->{expiration} = undef;
  $self->{user} = undef;
  $self->{publicUserInfo} = undef;
  $self->{noteStoreUrl} = undef;
  $self->{webApiUrlPrefix} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{currentTime}) {
      $self->{currentTime} = $vals->{currentTime};
    }
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
    if (defined $vals->{expiration}) {
      $self->{expiration} = $vals->{expiration};
    }
    if (defined $vals->{user}) {
      $self->{user} = $vals->{user};
    }
    if (defined $vals->{publicUserInfo}) {
      $self->{publicUserInfo} = $vals->{publicUserInfo};
    }
    if (defined $vals->{noteStoreUrl}) {
      $self->{noteStoreUrl} = $vals->{noteStoreUrl};
    }
    if (defined $vals->{webApiUrlPrefix}) {
      $self->{webApiUrlPrefix} = $vals->{webApiUrlPrefix};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'AuthenticationResult';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{currentTime});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I64) {
        $xfer += $input->readI64(\$self->{expiration});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{user} = Net::Evernote::EDAMTypes::User->new();
        $xfer += $self->{user}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{publicUserInfo} = Net::Evernote::EDAMUserStore::PublicUserInfo->new();
        $xfer += $self->{publicUserInfo}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{noteStoreUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{webApiUrlPrefix});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('AuthenticationResult');
  if (defined $self->{currentTime}) {
    $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
    $xfer += $output->writeI64($self->{currentTime});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 2);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{expiration}) {
    $xfer += $output->writeFieldBegin('expiration', TType::I64, 3);
    $xfer += $output->writeI64($self->{expiration});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{user}) {
    $xfer += $output->writeFieldBegin('user', TType::STRUCT, 4);
    $xfer += $self->{user}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{publicUserInfo}) {
    $xfer += $output->writeFieldBegin('publicUserInfo', TType::STRUCT, 5);
    $xfer += $self->{publicUserInfo}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{noteStoreUrl}) {
    $xfer += $output->writeFieldBegin('noteStoreUrl', TType::STRING, 6);
    $xfer += $output->writeString($self->{noteStoreUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{webApiUrlPrefix}) {
    $xfer += $output->writeFieldBegin('webApiUrlPrefix', TType::STRING, 7);
    $xfer += $output->writeString($self->{webApiUrlPrefix});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::BootstrapSettings;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::BootstrapSettings->mk_accessors( qw( serviceHost marketingUrl supportUrl accountEmailDomain enableFacebookSharing enableGiftSubscriptions enableSupportTickets enableSharedNotebooks enableSingleNoteSharing enableSponsored...

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{serviceHost} = undef;
  $self->{marketingUrl} = undef;
  $self->{supportUrl} = undef;
  $self->{accountEmailDomain} = undef;
  $self->{enableFacebookSharing} = undef;
  $self->{enableGiftSubscriptions} = undef;
  $self->{enableSupportTickets} = undef;
  $self->{enableSharedNotebooks} = undef;
  $self->{enableSingleNoteSharing} = undef;
  $self->{enableSponsoredAccounts} = undef;
  $self->{enableTwitterSharing} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{serviceHost}) {
      $self->{serviceHost} = $vals->{serviceHost};
    }
    if (defined $vals->{marketingUrl}) {
      $self->{marketingUrl} = $vals->{marketingUrl};
    }
    if (defined $vals->{supportUrl}) {
      $self->{supportUrl} = $vals->{supportUrl};
    }
    if (defined $vals->{accountEmailDomain}) {
      $self->{accountEmailDomain} = $vals->{accountEmailDomain};
    }
    if (defined $vals->{enableFacebookSharing}) {
      $self->{enableFacebookSharing} = $vals->{enableFacebookSharing};
    }
    if (defined $vals->{enableGiftSubscriptions}) {
      $self->{enableGiftSubscriptions} = $vals->{enableGiftSubscriptions};
    }
    if (defined $vals->{enableSupportTickets}) {
      $self->{enableSupportTickets} = $vals->{enableSupportTickets};
    }
    if (defined $vals->{enableSharedNotebooks}) {
      $self->{enableSharedNotebooks} = $vals->{enableSharedNotebooks};
    }
    if (defined $vals->{enableSingleNoteSharing}) {
      $self->{enableSingleNoteSharing} = $vals->{enableSingleNoteSharing};
    }
    if (defined $vals->{enableSponsoredAccounts}) {
      $self->{enableSponsoredAccounts} = $vals->{enableSponsoredAccounts};
    }
    if (defined $vals->{enableTwitterSharing}) {
      $self->{enableTwitterSharing} = $vals->{enableTwitterSharing};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'BootstrapSettings';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{serviceHost});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{marketingUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{supportUrl});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{accountEmailDomain});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^5$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableFacebookSharing});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^6$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableGiftSubscriptions});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^7$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableSupportTickets});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^8$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableSharedNotebooks});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^9$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableSingleNoteSharing});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^10$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableSponsoredAccounts});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^11$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{enableTwitterSharing});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('BootstrapSettings');
  if (defined $self->{serviceHost}) {
    $xfer += $output->writeFieldBegin('serviceHost', TType::STRING, 1);
    $xfer += $output->writeString($self->{serviceHost});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{marketingUrl}) {
    $xfer += $output->writeFieldBegin('marketingUrl', TType::STRING, 2);
    $xfer += $output->writeString($self->{marketingUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{supportUrl}) {
    $xfer += $output->writeFieldBegin('supportUrl', TType::STRING, 3);
    $xfer += $output->writeString($self->{supportUrl});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{accountEmailDomain}) {
    $xfer += $output->writeFieldBegin('accountEmailDomain', TType::STRING, 4);
    $xfer += $output->writeString($self->{accountEmailDomain});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableFacebookSharing}) {
    $xfer += $output->writeFieldBegin('enableFacebookSharing', TType::BOOL, 5);
    $xfer += $output->writeBool($self->{enableFacebookSharing});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableGiftSubscriptions}) {
    $xfer += $output->writeFieldBegin('enableGiftSubscriptions', TType::BOOL, 6);
    $xfer += $output->writeBool($self->{enableGiftSubscriptions});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableSupportTickets}) {
    $xfer += $output->writeFieldBegin('enableSupportTickets', TType::BOOL, 7);
    $xfer += $output->writeBool($self->{enableSupportTickets});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableSharedNotebooks}) {
    $xfer += $output->writeFieldBegin('enableSharedNotebooks', TType::BOOL, 8);
    $xfer += $output->writeBool($self->{enableSharedNotebooks});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableSingleNoteSharing}) {
    $xfer += $output->writeFieldBegin('enableSingleNoteSharing', TType::BOOL, 9);
    $xfer += $output->writeBool($self->{enableSingleNoteSharing});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableSponsoredAccounts}) {
    $xfer += $output->writeFieldBegin('enableSponsoredAccounts', TType::BOOL, 10);
    $xfer += $output->writeBool($self->{enableSponsoredAccounts});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{enableTwitterSharing}) {
    $xfer += $output->writeFieldBegin('enableTwitterSharing', TType::BOOL, 11);
    $xfer += $output->writeBool($self->{enableTwitterSharing});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::BootstrapProfile;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::BootstrapProfile->mk_accessors( qw( name settings ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{name} = undef;
  $self->{settings} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{name}) {
      $self->{name} = $vals->{name};
    }
    if (defined $vals->{settings}) {
      $self->{settings} = $vals->{settings};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'BootstrapProfile';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{name});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{settings} = Net::Evernote::EDAMUserStore::BootstrapSettings->new();
        $xfer += $self->{settings}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('BootstrapProfile');
  if (defined $self->{name}) {
    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
    $xfer += $output->writeString($self->{name});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{settings}) {
    $xfer += $output->writeFieldBegin('settings', TType::STRUCT, 2);
    $xfer += $self->{settings}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::BootstrapInfo;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::BootstrapInfo->mk_accessors( qw( profiles ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{profiles} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{profiles}) {
      $self->{profiles} = $vals->{profiles};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'BootstrapInfo';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::LIST) {
        {
          my $_size0 = 0;
          $self->{profiles} = [];
          my $_etype3 = 0;
          $xfer += $input->readListBegin(\$_etype3, \$_size0);
          for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
          {
            my $elem5 = undef;
            $elem5 = Net::Evernote::EDAMUserStore::BootstrapProfile->new();
            $xfer += $elem5->read($input);
            push(@{$self->{profiles}},$elem5);
          }
          $xfer += $input->readListEnd();
        }
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('BootstrapInfo');
  if (defined $self->{profiles}) {
    $xfer += $output->writeFieldBegin('profiles', TType::LIST, 1);
    {
      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{profiles}}));
      {
        foreach my $iter6 (@{$self->{profiles}}) 
        {
          $xfer += ${iter6}->write($output);
        }
      }
      $xfer += $output->writeListEnd();
    }
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

1;

lib/Net/Evernote/EDAMUserStore/UserStore.pm  view on Meta::CPAN

#
# Autogenerated by Thrift Compiler (0.9.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
require 5.6.0;
use strict;
use warnings;
use Thrift;

use Net::Evernote::EDAMUserStore::Types;

# HELPER FUNCTIONS AND STRUCTURES

package Net::Evernote::EDAMUserStore::UserStore_checkVersion_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_checkVersion_args->mk_accessors( qw( clientName edamVersionMajor edamVersionMinor ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{clientName} = undef;
  $self->{edamVersionMajor} = 1;
  $self->{edamVersionMinor} = 21;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{clientName}) {
      $self->{clientName} = $vals->{clientName};
    }
    if (defined $vals->{edamVersionMajor}) {
      $self->{edamVersionMajor} = $vals->{edamVersionMajor};
    }
    if (defined $vals->{edamVersionMinor}) {
      $self->{edamVersionMinor} = $vals->{edamVersionMinor};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_checkVersion_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{clientName});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{edamVersionMajor});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::I16) {
        $xfer += $input->readI16(\$self->{edamVersionMinor});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_checkVersion_args');
  if (defined $self->{clientName}) {
    $xfer += $output->writeFieldBegin('clientName', TType::STRING, 1);
    $xfer += $output->writeString($self->{clientName});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{edamVersionMajor}) {
    $xfer += $output->writeFieldBegin('edamVersionMajor', TType::I16, 2);
    $xfer += $output->writeI16($self->{edamVersionMajor});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{edamVersionMinor}) {
    $xfer += $output->writeFieldBegin('edamVersionMinor', TType::I16, 3);
    $xfer += $output->writeI16($self->{edamVersionMinor});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_checkVersion_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_checkVersion_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_checkVersion_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::BOOL) {
        $xfer += $input->readBool(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_checkVersion_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
    $xfer += $output->writeBool($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_args->mk_accessors( qw( locale ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{locale} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{locale}) {
      $self->{locale} = $vals->{locale};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getBootstrapInfo_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{locale});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getBootstrapInfo_args');
  if (defined $self->{locale}) {
    $xfer += $output->writeFieldBegin('locale', TType::STRING, 1);
    $xfer += $output->writeString($self->{locale});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getBootstrapInfo_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::BootstrapInfo->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getBootstrapInfo_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_authenticate_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_authenticate_args->mk_accessors( qw( username password consumerKey consumerSecret ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{username} = undef;
  $self->{password} = undef;
  $self->{consumerKey} = undef;
  $self->{consumerSecret} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
    if (defined $vals->{password}) {
      $self->{password} = $vals->{password};
    }
    if (defined $vals->{consumerKey}) {
      $self->{consumerKey} = $vals->{consumerKey};
    }
    if (defined $vals->{consumerSecret}) {
      $self->{consumerSecret} = $vals->{consumerSecret};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_authenticate_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{password});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{consumerKey});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^4$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{consumerSecret});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_authenticate_args');
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 1);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{password}) {
    $xfer += $output->writeFieldBegin('password', TType::STRING, 2);
    $xfer += $output->writeString($self->{password});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{consumerKey}) {
    $xfer += $output->writeFieldBegin('consumerKey', TType::STRING, 3);
    $xfer += $output->writeString($self->{consumerKey});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{consumerSecret}) {
    $xfer += $output->writeFieldBegin('consumerSecret', TType::STRING, 4);
    $xfer += $output->writeString($self->{consumerSecret});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_authenticate_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_authenticate_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_authenticate_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_authenticate_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_refreshAuthentication_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_refreshAuthentication_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_refreshAuthentication_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_refreshAuthentication_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getUser_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getUser_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getUser_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getUser_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getUser_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getUser_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getUser_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMTypes::User->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getUser_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_args->mk_accessors( qw( username ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{username} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{username}) {
      $self->{username} = $vals->{username};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getPublicUserInfo_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{username});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getPublicUserInfo_args');
  if (defined $self->{username}) {
    $xfer += $output->writeFieldBegin('username', TType::STRING, 1);
    $xfer += $output->writeString($self->{username});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{notFoundException} = undef;
  $self->{systemException} = undef;
  $self->{userException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{notFoundException}) {
      $self->{notFoundException} = $vals->{notFoundException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getPublicUserInfo_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::PublicUserInfo->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
        $xfer += $self->{notFoundException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^3$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getPublicUserInfo_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{notFoundException}) {
    $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 1);
    $xfer += $self->{notFoundException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 3);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getPremiumInfo_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getPremiumInfo_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getPremiumInfo_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{success} = Net::Evernote::EDAMUserStore::PremiumInfo->new();
        $xfer += $self->{success}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getPremiumInfo_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
    $xfer += $self->{success}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_args;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_args->mk_accessors( qw( authenticationToken ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{authenticationToken} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{authenticationToken}) {
      $self->{authenticationToken} = $vals->{authenticationToken};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getNoteStoreUrl_args';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^1$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{authenticationToken});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getNoteStoreUrl_args');
  if (defined $self->{authenticationToken}) {
    $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
    $xfer += $output->writeString($self->{authenticationToken});
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_result;
use base qw(Class::Accessor);
Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_result->mk_accessors( qw( success ) );

sub new {
  my $classname = shift;
  my $self      = {};
  my $vals      = shift || {};
  $self->{success} = undef;
  $self->{userException} = undef;
  $self->{systemException} = undef;
  if (UNIVERSAL::isa($vals,'HASH')) {
    if (defined $vals->{success}) {
      $self->{success} = $vals->{success};
    }
    if (defined $vals->{userException}) {
      $self->{userException} = $vals->{userException};
    }
    if (defined $vals->{systemException}) {
      $self->{systemException} = $vals->{systemException};
    }
  }
  return bless ($self, $classname);
}

sub getName {
  return 'UserStore_getNoteStoreUrl_result';
}

sub read {
  my ($self, $input) = @_;
  my $xfer  = 0;
  my $fname;
  my $ftype = 0;
  my $fid   = 0;
  $xfer += $input->readStructBegin(\$fname);
  while (1) 
  {
    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
    if ($ftype == TType::STOP) {
      last;
    }
    SWITCH: for($fid)
    {
      /^0$/ && do{      if ($ftype == TType::STRING) {
        $xfer += $input->readString(\$self->{success});
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^1$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
        $xfer += $self->{userException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
      /^2$/ && do{      if ($ftype == TType::STRUCT) {
        $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
        $xfer += $self->{systemException}->read($input);
      } else {
        $xfer += $input->skip($ftype);
      }
      last; };
        $xfer += $input->skip($ftype);
    }
    $xfer += $input->readFieldEnd();
  }
  $xfer += $input->readStructEnd();
  return $xfer;
}

sub write {
  my ($self, $output) = @_;
  my $xfer   = 0;
  $xfer += $output->writeStructBegin('UserStore_getNoteStoreUrl_result');
  if (defined $self->{success}) {
    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
    $xfer += $output->writeString($self->{success});
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{userException}) {
    $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
    $xfer += $self->{userException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  if (defined $self->{systemException}) {
    $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
    $xfer += $self->{systemException}->write($output);
    $xfer += $output->writeFieldEnd();
  }
  $xfer += $output->writeFieldStop();
  $xfer += $output->writeStructEnd();
  return $xfer;
}

package Net::Evernote::EDAMUserStore::UserStoreIf;

use strict;


sub checkVersion{
  my $self = shift;
  my $clientName = shift;
  my $edamVersionMajor = shift;
  my $edamVersionMinor = shift;

  die 'implement interface';
}

sub getBootstrapInfo{
  my $self = shift;
  my $locale = shift;

  die 'implement interface';
}

sub authenticate{
  my $self = shift;
  my $username = shift;
  my $password = shift;
  my $consumerKey = shift;
  my $consumerSecret = shift;

  die 'implement interface';
}

sub refreshAuthentication{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getUser{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getPublicUserInfo{
  my $self = shift;
  my $username = shift;

  die 'implement interface';
}

sub getPremiumInfo{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

sub getNoteStoreUrl{
  my $self = shift;
  my $authenticationToken = shift;

  die 'implement interface';
}

package Net::Evernote::EDAMUserStore::UserStoreRest;

use strict;


sub new {
  my ($classname, $impl) = @_;
  my $self     ={ impl => $impl };

  return bless($self,$classname);
}

sub checkVersion{
  my ($self, $request) = @_;

  my $clientName = ($request->{'clientName'}) ? $request->{'clientName'} : undef;
  my $edamVersionMajor = ($request->{'edamVersionMajor'}) ? $request->{'edamVersionMajor'} : undef;
  my $edamVersionMinor = ($request->{'edamVersionMinor'}) ? $request->{'edamVersionMinor'} : undef;
  return $self->{impl}->checkVersion($clientName, $edamVersionMajor, $edamVersionMinor);
}

sub getBootstrapInfo{
  my ($self, $request) = @_;

  my $locale = ($request->{'locale'}) ? $request->{'locale'} : undef;
  return $self->{impl}->getBootstrapInfo($locale);
}

sub authenticate{
  my ($self, $request) = @_;

  my $username = ($request->{'username'}) ? $request->{'username'} : undef;
  my $password = ($request->{'password'}) ? $request->{'password'} : undef;
  my $consumerKey = ($request->{'consumerKey'}) ? $request->{'consumerKey'} : undef;
  my $consumerSecret = ($request->{'consumerSecret'}) ? $request->{'consumerSecret'} : undef;
  return $self->{impl}->authenticate($username, $password, $consumerKey, $consumerSecret);
}

sub refreshAuthentication{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->refreshAuthentication($authenticationToken);
}

sub getUser{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getUser($authenticationToken);
}

sub getPublicUserInfo{
  my ($self, $request) = @_;

  my $username = ($request->{'username'}) ? $request->{'username'} : undef;
  return $self->{impl}->getPublicUserInfo($username);
}

sub getPremiumInfo{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getPremiumInfo($authenticationToken);
}

sub getNoteStoreUrl{
  my ($self, $request) = @_;

  my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
  return $self->{impl}->getNoteStoreUrl($authenticationToken);
}

package Net::Evernote::EDAMUserStore::UserStoreClient;


use base qw(Net::Evernote::EDAMUserStore::UserStoreIf);
sub new {
  my ($classname, $input, $output) = @_;
  my $self      = {};
  $self->{input}  = $input;
  $self->{output} = defined $output ? $output : $input;
  $self->{seqid}  = 0;
  return bless($self,$classname);
}

sub checkVersion{
  my $self = shift;
  my $clientName = shift;
  my $edamVersionMajor = shift;
  my $edamVersionMinor = shift;

    $self->send_checkVersion($clientName, $edamVersionMajor, $edamVersionMinor);
  return $self->recv_checkVersion();
}

sub send_checkVersion{
  my $self = shift;
  my $clientName = shift;
  my $edamVersionMajor = shift;
  my $edamVersionMinor = shift;

  $self->{output}->writeMessageBegin('checkVersion', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_checkVersion_args->new();
  $args->{clientName} = $clientName;
  $args->{edamVersionMajor} = $edamVersionMajor;
  $args->{edamVersionMinor} = $edamVersionMinor;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_checkVersion{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_checkVersion_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "checkVersion failed: unknown result";
}
sub getBootstrapInfo{
  my $self = shift;
  my $locale = shift;

    $self->send_getBootstrapInfo($locale);
  return $self->recv_getBootstrapInfo();
}

sub send_getBootstrapInfo{
  my $self = shift;
  my $locale = shift;

  $self->{output}->writeMessageBegin('getBootstrapInfo', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_args->new();
  $args->{locale} = $locale;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getBootstrapInfo{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  die "getBootstrapInfo failed: unknown result";
}
sub authenticate{
  my $self = shift;
  my $username = shift;
  my $password = shift;
  my $consumerKey = shift;
  my $consumerSecret = shift;

    $self->send_authenticate($username, $password, $consumerKey, $consumerSecret);
  return $self->recv_authenticate();
}

sub send_authenticate{
  my $self = shift;
  my $username = shift;
  my $password = shift;
  my $consumerKey = shift;
  my $consumerSecret = shift;

  $self->{output}->writeMessageBegin('authenticate', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_authenticate_args->new();
  $args->{username} = $username;
  $args->{password} = $password;
  $args->{consumerKey} = $consumerKey;
  $args->{consumerSecret} = $consumerSecret;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_authenticate{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_authenticate_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "authenticate failed: unknown result";
}
sub refreshAuthentication{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_refreshAuthentication($authenticationToken);
  return $self->recv_refreshAuthentication();
}

sub send_refreshAuthentication{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('refreshAuthentication', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_refreshAuthentication{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "refreshAuthentication failed: unknown result";
}
sub getUser{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getUser($authenticationToken);
  return $self->recv_getUser();
}

sub send_getUser{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getUser', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_getUser_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getUser{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_getUser_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getUser failed: unknown result";
}
sub getPublicUserInfo{
  my $self = shift;
  my $username = shift;

    $self->send_getPublicUserInfo($username);
  return $self->recv_getPublicUserInfo();
}

sub send_getPublicUserInfo{
  my $self = shift;
  my $username = shift;

  $self->{output}->writeMessageBegin('getPublicUserInfo', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_args->new();
  $args->{username} = $username;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getPublicUserInfo{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{notFoundException}) {
    die $result->{notFoundException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  die "getPublicUserInfo failed: unknown result";
}
sub getPremiumInfo{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getPremiumInfo($authenticationToken);
  return $self->recv_getPremiumInfo();
}

sub send_getPremiumInfo{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getPremiumInfo', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getPremiumInfo{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getPremiumInfo failed: unknown result";
}
sub getNoteStoreUrl{
  my $self = shift;
  my $authenticationToken = shift;

    $self->send_getNoteStoreUrl($authenticationToken);
  return $self->recv_getNoteStoreUrl();
}

sub send_getNoteStoreUrl{
  my $self = shift;
  my $authenticationToken = shift;

  $self->{output}->writeMessageBegin('getNoteStoreUrl', TMessageType::CALL, $self->{seqid});
  my $args = Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_args->new();
  $args->{authenticationToken} = $authenticationToken;
  $args->write($self->{output});
  $self->{output}->writeMessageEnd();
  $self->{output}->getTransport()->flush();
}

sub recv_getNoteStoreUrl{
  my $self = shift;

  my $rseqid = 0;
  my $fname;
  my $mtype = 0;

  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
  if ($mtype == TMessageType::EXCEPTION) {
    my $x = TApplicationException->new();
    $x->read($self->{input});
    $self->{input}->readMessageEnd();
    die $x;
  }
  my $result = Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_result->new();
  $result->read($self->{input});
  $self->{input}->readMessageEnd();

  if (defined $result->{success} ) {
    return $result->{success};
  }
  if (defined $result->{userException}) {
    die $result->{userException};
  }
  if (defined $result->{systemException}) {
    die $result->{systemException};
  }
  die "getNoteStoreUrl failed: unknown result";
}
package Net::Evernote::EDAMUserStore::UserStoreProcessor;

use strict;


sub new {
    my ($classname, $handler) = @_;
    my $self      = {};
    $self->{handler} = $handler;
    return bless ($self, $classname);
}

sub process {
    my ($self, $input, $output) = @_;
    my $rseqid = 0;
    my $fname  = undef;
    my $mtype  = 0;

    $input->readMessageBegin(\$fname, \$mtype, \$rseqid);
    my $methodname = 'process_'.$fname;
    if (!$self->can($methodname)) {
      $input->skip(TType::STRUCT);
      $input->readMessageEnd();
      my $x = TApplicationException->new('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
      $output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
      $x->write($output);
      $output->writeMessageEnd();
      $output->getTransport()->flush();
      return;
    }
    $self->$methodname($rseqid, $input, $output);
    return 1;
}

sub process_checkVersion {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_checkVersion_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_checkVersion_result->new();
    $result->{success} = $self->{handler}->checkVersion($args->clientName, $args->edamVersionMajor, $args->edamVersionMinor);
    $output->writeMessageBegin('checkVersion', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getBootstrapInfo {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_getBootstrapInfo_result->new();
    $result->{success} = $self->{handler}->getBootstrapInfo($args->locale);
    $output->writeMessageBegin('getBootstrapInfo', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_authenticate {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_authenticate_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_authenticate_result->new();
    eval {
      $result->{success} = $self->{handler}->authenticate($args->username, $args->password, $args->consumerKey, $args->consumerSecret);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('authenticate', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_refreshAuthentication {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_refreshAuthentication_result->new();
    eval {
      $result->{success} = $self->{handler}->refreshAuthentication($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('refreshAuthentication', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getUser {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_getUser_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_getUser_result->new();
    eval {
      $result->{success} = $self->{handler}->getUser($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getUser', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getPublicUserInfo {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_getPublicUserInfo_result->new();
    eval {
      $result->{success} = $self->{handler}->getPublicUserInfo($args->username);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){ 
      $result->{notFoundException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
    }
    $output->writeMessageBegin('getPublicUserInfo', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getPremiumInfo {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_getPremiumInfo_result->new();
    eval {
      $result->{success} = $self->{handler}->getPremiumInfo($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getPremiumInfo', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

sub process_getNoteStoreUrl {
    my ($self, $seqid, $input, $output) = @_;
    my $args = Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_args->new();
    $args->read($input);
    $input->readMessageEnd();
    my $result = Net::Evernote::EDAMUserStore::UserStore_getNoteStoreUrl_result->new();
    eval {
      $result->{success} = $self->{handler}->getNoteStoreUrl($args->authenticationToken);
    }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){ 
      $result->{userException} = $@;
        }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){ 
      $result->{systemException} = $@;
    }
    $output->writeMessageBegin('getNoteStoreUrl', TMessageType::REPLY, $seqid);
    $result->write($output);
    $output->writeMessageEnd();
    $output->getTransport()->flush();
}

1;

lib/Net/Evernote/Note.pm  view on Meta::CPAN

package Net::Evernote::Note;

use warnings;
use strict;
our $VERSION = '0.07';

sub new {
    my ($class, $args) = @_;
    my $debug = $ENV{DEBUG};
    
    return bless { 
        _obj        => $$args{_obj},
        _notestore => $$args{_notestore},
        _authentication_token       => $$args{_authentication_token},
        debug       => $debug,
    }, $class;
}

# return all of the note's Tag objects
sub tags {
    
}

sub delete {
    my ($self) = @_;

    my $authToken = $self->{_authentication_token};
    my $client = $self->{_notestore};
    my $guid = $self->guid;
    return $client->deleteNote($authToken,$guid);
}

sub tagNames {
    my $self = shift;

    my $obj  = $self->{_obj};
    my $ns   = $self->{_notestore};
    my $auth = $self->{_authentication_token};
    my $guids = $obj->tagGuids;

    return undef if !$guids;
    my @tag_names = map {
        $ns->getTag($auth, $_)->name;
    } @$guids;

    return wantarray ? @tag_names : \@tag_names;
}

# the magic
sub AUTOLOAD {
    my ($self,@args) = @_;
    our ($AUTOLOAD);
    my $method = $AUTOLOAD;
    $method =~ s/.*:://;

    if ($self->{_obj}->can($method)) {
        return $self->{_obj}->$method;
    } else {
        # FIXME: would be better to get feedback about a non-existing method
        return undef;
    }
}

1;

__END__

1;


=head1 NAME

Net::Evernote::Note

=head1 VERSION

Version 0.06


=head1 SYNOPSIS

    use Net::Evernote;
    use Net::Evernote::Note;

    my $evernote = Net::Evernote->new({
        authentication_token => $authentication_token
    });

my $note_title = 'test title';
my $note_tags  = [qw(evernote-perl-api-test-tag-1 evernote-perl-api-test-tag-2)];

# let's throw a date in there:
my $dt = DateTime->new(
    year   => 1981,
    month  => 4,
    day    => 4,
    hour   => 13,
    minute => 30,
    time_zone => 'EST'
);

my $epoch_time  = $dt->epoch;

my $note = $evernote->createNote({
    title     => $note_title,
    content   => 'here is some test content',
    tag_names => $note_tags,
    created   => $epoch_time*1000,
});

my $guid = $note->guid;

my $new_note = $evernote->getNote({
    guid => $guid,
});

# delete it
$new_note->delete;

=head1 SEE ALSO

http://www.evernote.com/about/developer/api/


=head1 AUTHOR

David Collins <davidcollins4481@gmail.com>

=head1 BUGS/LIMITATIONS

If you have found bugs, please send email to <davidcollins4481@gmail.com>


=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Net::Evernote::Note


=head1 COPYRIGHT & LICENSE

Copyright 2013 David Collins, all rights reserved.

This program is free software; you can redistribute it and/or modify 
it under the same terms as Perl itself.

lib/Net/Evernote/Notebook.pm  view on Meta::CPAN

package Net::Evernote::Notebook;

use strict;
use warnings;
our $VERSION = '0.07';

sub new {
    my ($class, $args) = @_;
    my $debug = $ENV{DEBUG};
    my $obj = $$args{_obj};

    return bless { 
        _obj        => $obj,
        _authentication_token  => $$args{_authentication_token},
        _notestore  => $$args{_notestore},
        debug       => $debug,
        name        => $$args{name},
    }, $class;
}

sub delete {
    my $self = shift; 
    my $guid = $self->guid;
    my $authToken = $self->{_authentication_token};
    my $client = $self->{_notestore};

    return $client->expungeNotebook($authToken,$guid);
}

# the magic
sub AUTOLOAD {
    my ($self,@args) = @_;
    our ($AUTOLOAD);
    my $method = $AUTOLOAD;
    $method =~ s/.*:://;

    if ($self->{_obj}->can($method)) {
        return $self->{_obj}->$method;
    } else {
        return undef;
    }
}

1;

=head1 NAME

Net::Evernote::Notebook

=head1 VERSION

Version 0.06


=head1 SYNOPSIS

    use Net::Evernote;
    use Net::Evernote::Notebook;

    my $evernote = Net::Evernote->new({
        authentication_token => $authentication_token
    });

    my $notebook = $evernote->createNotebook({
        name => 'notebook name',
    });

    my $notebookGuid = $notebook->guid;
    my $note = $evernote->createNote({
        title         => 'test title',
        content       => 'test content',
        notebook_guid => $notebookGuid,
    });

=head1 SEE ALSO

http://www.evernote.com/about/developer/api/


=head1 AUTHOR

David Collins <davidcollins4481@gmail.com>

=head1 BUGS/LIMITATIONS

If you have found bugs, please send email to <davidcollins4481@gmail.com>


=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Net::Evernote::Notebook


=head1 COPYRIGHT & LICENSE

Copyright 2013 David Collins, all rights reserved.

This program is free software; you can redistribute it and/or modify 
it under the same terms as Perl itself.

lib/Net/Evernote/Tag.pm  view on Meta::CPAN

package Net::Evernote::Tag;

use strict;
use warnings;
our $VERSION = '0.07';

sub new {
    my ($class, $args) = @_;
    my $debug = $ENV{DEBUG};

    if (!$$args{_obj} && !$$args{name} && !$$args{guid}) {
        die "Name or Guid required to create/retrieve a tag\n";
    }

    my $obj = $$args{_obj};

    return bless { 
        _obj        => $obj,
        _authentication_token  => $$args{_authentication_token},
        debug       => $debug,
        _notestore  => $$args{_notestore},
    }, $class;
}

sub delete {
    my ($self, $args) = @_;
    my $guid = $self->guid;

    my $authToken = $self->{_authentication_token};
    my $client = $self->{_notestore};

    return $client->expungeTag($authToken,$guid);
}

# the magic
sub AUTOLOAD {
    my ($self,@args) = @_;
    our ($AUTOLOAD);
    my $method = $AUTOLOAD;
    $method =~ s/.*:://;

    if ($self->{_obj}->can($method)) {
        return $self->{_obj}->$method;
    } else {
        return undef;
    }
}
1;



=head1 NAME

Net::Evernote::Tag

=head1 VERSION

Version 0.06


=head1 SYNOPSIS

    use Net::Evernote;
    use Net::Evernote::Tag;

    my $evernote = Net::Evernote->new({
        authentication_token => $authentication_token
    });

    my $tag = $evernote->createTag({'name' => $tag_name });
    $tag_guid = $tag->guid;

    my $tag = $evernote->getTag({
        guid => $tag_guid, 
    });

    my $note = $evernote->getNote({
        guid => $note_guid,
    });

    my $tagGuids = $note->tagGuids;

=head1 SEE ALSO

http://www.evernote.com/about/developer/api/


=head1 AUTHOR

David Collins <davidcollins4481@gmail.com>

=head1 BUGS/LIMITATIONS

If you have found bugs, please send email to <davidcollins4481@gmail.com>


=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Net::Evernote::Tag


=head1 COPYRIGHT & LICENSE

Copyright 2013 David Collins, all rights reserved.

This program is free software; you can redistribute it and/or modify 
it under the same terms as Perl itself.

t/00-authentication.t  view on Meta::CPAN

use strict;
use warnings;
use Test::More qw(no_plan);
use FindBin;
use lib $FindBin::Bin;
use Net::Evernote;

use Common qw(:DEFAULT $config);

BEGIN { use_ok('Net::Evernote') };

my $evernote = Net::Evernote->new({
    authentication_token  => $$config{'authentication_token'},
    use_sandbox => 1,
});

ok($evernote->authenticated eq 1, 'Successfully authenticated user');

t/01-note.t  view on Meta::CPAN

use strict;
use warnings;
use Test::More qw(no_plan);
use FindBin;
use lib $FindBin::Bin;
use Net::Evernote;
use DateTime;


use Common qw(:DEFAULT $config);

my $evernote = Net::Evernote->new({
    authentication_token => $$config{'authentication_token'},
    use_sandbox => 1,
});

my $note_title = 'test title';
my $note_tags  = [qw(evernote-perl-api-test-tag-1 evernote-perl-api-test-tag-2)];

# let's throw a date in there:
my $dt = DateTime->new(
    year   => 1981,
    month  => 4,
    day    => 4,
    hour   => 13,
    minute => 30,
    time_zone => 'EST'
);

my $epoch_time  = $dt->epoch;

my $note = $evernote->createNote({
    title     => $note_title,
    content   => 'here is some test content',
    tag_names => $note_tags,
    created   => $epoch_time*1000,
});

my $guid = $note->guid;

my $new_note = $evernote->getNote({
    guid => $guid,
});

ok($guid eq $new_note->guid, 'New note successfully retrieved');

# FIXME: content returns with markup so not testing that here
ok($note_title eq $new_note->title, 'Title of new note successfully retrieved');

ok($new_note->active == 1, 'Note is active');

my $tags = $new_note->tagNames;
ok(@$tags ~~ @$note_tags, "Tags look good");

# delete the test note
$evernote->deleteNote({
    guid => $guid
});

my $deleted_note = $evernote->getNote({
    guid => $guid,
});

ok($deleted_note->deleted ne '', "Note deleted");
ok($deleted_note->active != 1, "Note is no longer active");

# Hmmm...what to do with the tags? I don't want to accidentally delete a tag from someone's
# Evernote account that previously existed. Maybe a huge random tag or something?

t/02-notebook.t  view on Meta::CPAN

use strict;
use warnings;

use Test::More qw(no_plan);
use Net::Evernote;
use FindBin;

use lib $FindBin::Bin;
use Common qw(:DEFAULT $config);

my $evernote = Net::Evernote->new({
    authentication_token => $$config{'authentication_token'},
    use_sandbox => 1,
});

my $notebookName = 'test_notebook-new'. time;
my $notebookGuid;

# create a notebook
{
    my $notebook = $evernote->createNotebook({
        name => $notebookName,
    });

    $notebookGuid = $notebook->guid;

    isnt($notebookGuid, '', "Notebook created with GUID ${notebookGuid}");

}

# put a note in the notebook
{
    my $note = $evernote->createNote({
        title         => 'test title',
        content       => 'test content',
        notebook_guid => $notebookGuid,
    });

    ok($note->guid && $note->notebookGuid eq $notebookGuid , 'Note created in new notebook');

    $note->delete;
    my $notebook = $evernote->getNotebook({ guid => $notebookGuid });
    ok($notebook->guid eq $notebookGuid, "Notebook retrieved");
}

# delete the notebook
{
    my $notebook = $evernote->getNotebook({ guid => $notebookGuid });
    # @return The Update Sequence Number for this change within the account.
    # I guess this means a positive value = success ?
    my $deleted = $notebook->delete;
    ok(!!$deleted, "Notebook deleted");

    # try to get the notebook again
    my $deleted_notebook = $evernote->getNotebook({ guid => $notebookGuid });
    is($deleted_notebook, undef, "Notebook not retrieved after deletion");
}

t/03-tag.t  view on Meta::CPAN

use strict;
use warnings;
use Test::More qw(no_plan);

use FindBin;
use lib $FindBin::Bin;
use Net::Evernote;

use Common qw(:DEFAULT $config);

my $evernote = Net::Evernote->new({
    authentication_token => $$config{'authentication_token'},
    use_sandbox => 1,
});

my $tag_name = 'test tag-' . time;
my ($tagGuid, $note_guid);

# create a tag
{
    my $tag = $evernote->createTag({'name' => $tag_name });
    ok($tag->name eq $tag_name, "Tag name retrieved");
    $tagGuid = $tag->guid;
    isnt($tagGuid, '', "Tag has GUID (${tagGuid})");
}

# create a note and apply the tag
{
    my $note = $evernote->createNote({
        title     => 'tag tester',
        content   => 'tag test content',
        tag_guids => [$tagGuid],
    });

    $note_guid = $note->guid;
}

# retrieve the tag and it's notes
{
    my $tag = $evernote->getTag({
        guid => $tagGuid, 
    });

    is($tag->guid, $tagGuid, "Tag retrieved by GUID (${tagGuid})");

    my $note = $evernote->getNote({
        guid => $note_guid,
    });

    my $tagGuids = $note->tagGuids;

    # only set one...check that
    my $firstTagGuid = $$tagGuids[0];
    is($firstTagGuid, $tagGuid, "Tag successfully attached to note");

    # delete tag and note
    my $deleted_note = $note->delete;
    my $deleted = $tag->delete;

    ok(!!$deleted, "Tag deleted");

   my $deleted_tag = $evernote->getTag({ guid => $tagGuid });
   is($deleted_tag, undef, "Tag not retrieved after deletion");
}

t/Common.pm  view on Meta::CPAN

package Common;
use base 'Exporter';

our @EXPORT_OK = qw($config);

our $config = {
    authentication_token      => 'S=s1:U=17f6f:E=14572b1de11:C=13e1b00b214:P=1cd:A=en-devtoken:V=2:H=7d28e083d0ac4c4597743241eb8e4292'
};

t/manifest.t  view on Meta::CPAN

#!perl -T

use strict;
use warnings;
use Test::More;

unless ( $ENV{RELEASE_TESTING} ) {
    plan( skip_all => "Author tests not required for installation" );
}

eval "use Test::CheckManifest 0.9";
plan skip_all => "Test::CheckManifest 0.9 required" if $@;
ok_manifest();