Evernote/EDAMNoteStore/NoteStore.pm untested

filter: Statementstmt 0.0% 0 / 15375 Branchbran 0.0% 0 / 4840 Conditioncond 0.0% 0 / 1676 MC/DCmcdc 0.0% 0 / 1068 Subroutinesub 0.0% 0 / 1197 Podpod 0.0% 0 / 1040 totaltotal 0.0% 0 / 25196 CC 2421 SCAR 32.9
CC
2421
Cov
0%
new
72.0
read
72.0
new
72.0
CRAP 26.9
1 #
2 # Autogenerated by Thrift Compiler (0.9.0)
3 #
4 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 #
6 require 5.6.0;
7 use strict;
8 use warnings;
9 use Thrift;
10  
11 use Net::Evernote::EDAMNoteStore::Types;
12  
13 # HELPER FUNCTIONS AND STRUCTURES
14  
15 package Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args;
16 use base qw(Class::Accessor);
17 Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->mk_accessors( qw( authenticationToken ) );
18  
19 sub new {
20 my $classname = shift;
21 my $self = {};
22 my $vals = shift || {};
23 $self->{authenticationToken} = undef;
24 if (UNIVERSAL::isa($vals,'HASH')) {
25 if (defined $vals->{authenticationToken}) {
26 $self->{authenticationToken} = $vals->{authenticationToken};
27 }
28 }
29 return bless ($self, $classname);
30 }
31  
32 sub getName {
33 return 'NoteStore_getSyncState_args';
34 }
35  
36 sub read {
37 my ($self, $input) = @_;
38 my $xfer = 0;
39 my $fname;
40 my $ftype = 0;
41 my $fid = 0;
42 $xfer += $input->readStructBegin(\$fname);
43 while (1)
44 {
45 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
46 if ($ftype == TType::STOP) {
47 last;
48 }
49 SWITCH: for($fid)
50 {
51 /^1$/ && do{ if ($ftype == TType::STRING) {
52 $xfer += $input->readString(\$self->{authenticationToken});
53 } else {
54 $xfer += $input->skip($ftype);
55 }
56 last; };
57 $xfer += $input->skip($ftype);
58 }
59 $xfer += $input->readFieldEnd();
60 }
61 $xfer += $input->readStructEnd();
62 return $xfer;
63 }
64  
65 sub write {
66 my ($self, $output) = @_;
67 my $xfer = 0;
68 $xfer += $output->writeStructBegin('NoteStore_getSyncState_args');
69 if (defined $self->{authenticationToken}) {
70 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
71 $xfer += $output->writeString($self->{authenticationToken});
72 $xfer += $output->writeFieldEnd();
73 }
74 $xfer += $output->writeFieldStop();
75 $xfer += $output->writeStructEnd();
76 return $xfer;
77 }
78  
79 package Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result;
80 use base qw(Class::Accessor);
81 Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->mk_accessors( qw( success ) );
82  
83 sub new {
84 my $classname = shift;
85 my $self = {};
86 my $vals = shift || {};
87 $self->{success} = undef;
88 $self->{userException} = undef;
89 $self->{systemException} = undef;
90 if (UNIVERSAL::isa($vals,'HASH')) {
91 if (defined $vals->{success}) {
92 $self->{success} = $vals->{success};
93 }
94 if (defined $vals->{userException}) {
95 $self->{userException} = $vals->{userException};
96 }
97 if (defined $vals->{systemException}) {
98 $self->{systemException} = $vals->{systemException};
99 }
100 }
101 return bless ($self, $classname);
102 }
103  
104 sub getName {
105 return 'NoteStore_getSyncState_result';
106 }
107  
108 sub read {
109 my ($self, $input) = @_;
110 my $xfer = 0;
111 my $fname;
112 my $ftype = 0;
113 my $fid = 0;
114 $xfer += $input->readStructBegin(\$fname);
115 while (1)
116 {
117 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
118 if ($ftype == TType::STOP) {
119 last;
120 }
121 SWITCH: for($fid)
122 {
123 /^0$/ && do{ if ($ftype == TType::STRUCT) {
124 $self->{success} = Net::Evernote::EDAMNoteStore::SyncState->new();
125 $xfer += $self->{success}->read($input);
126 } else {
127 $xfer += $input->skip($ftype);
128 }
129 last; };
130 /^1$/ && do{ if ($ftype == TType::STRUCT) {
131 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
132 $xfer += $self->{userException}->read($input);
133 } else {
134 $xfer += $input->skip($ftype);
135 }
136 last; };
137 /^2$/ && do{ if ($ftype == TType::STRUCT) {
138 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
139 $xfer += $self->{systemException}->read($input);
140 } else {
141 $xfer += $input->skip($ftype);
142 }
143 last; };
144 $xfer += $input->skip($ftype);
145 }
146 $xfer += $input->readFieldEnd();
147 }
148 $xfer += $input->readStructEnd();
149 return $xfer;
150 }
151  
152 sub write {
153 my ($self, $output) = @_;
154 my $xfer = 0;
155 $xfer += $output->writeStructBegin('NoteStore_getSyncState_result');
156 if (defined $self->{success}) {
157 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
158 $xfer += $self->{success}->write($output);
159 $xfer += $output->writeFieldEnd();
160 }
161 if (defined $self->{userException}) {
162 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
163 $xfer += $self->{userException}->write($output);
164 $xfer += $output->writeFieldEnd();
165 }
166 if (defined $self->{systemException}) {
167 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
168 $xfer += $self->{systemException}->write($output);
169 $xfer += $output->writeFieldEnd();
170 }
171 $xfer += $output->writeFieldStop();
172 $xfer += $output->writeStructEnd();
173 return $xfer;
174 }
175  
176 package Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args;
177 use base qw(Class::Accessor);
178 Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->mk_accessors( qw( authenticationToken afterUSN maxEntries fullSyncOnly ) );
179  
180 sub new {
181 my $classname = shift;
182 my $self = {};
183 my $vals = shift || {};
184 $self->{authenticationToken} = undef;
185 $self->{afterUSN} = undef;
186 $self->{maxEntries} = undef;
187 $self->{fullSyncOnly} = undef;
188 if (UNIVERSAL::isa($vals,'HASH')) {
189 if (defined $vals->{authenticationToken}) {
190 $self->{authenticationToken} = $vals->{authenticationToken};
191 }
192 if (defined $vals->{afterUSN}) {
193 $self->{afterUSN} = $vals->{afterUSN};
194 }
195 if (defined $vals->{maxEntries}) {
196 $self->{maxEntries} = $vals->{maxEntries};
197 }
198 if (defined $vals->{fullSyncOnly}) {
199 $self->{fullSyncOnly} = $vals->{fullSyncOnly};
200 }
201 }
202 return bless ($self, $classname);
203 }
204  
205 sub getName {
206 return 'NoteStore_getSyncChunk_args';
207 }
208  
209 sub read {
210 my ($self, $input) = @_;
211 my $xfer = 0;
212 my $fname;
213 my $ftype = 0;
214 my $fid = 0;
215 $xfer += $input->readStructBegin(\$fname);
216 while (1)
217 {
218 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
219 if ($ftype == TType::STOP) {
220 last;
221 }
222 SWITCH: for($fid)
223 {
224 /^1$/ && do{ if ($ftype == TType::STRING) {
225 $xfer += $input->readString(\$self->{authenticationToken});
226 } else {
227 $xfer += $input->skip($ftype);
228 }
229 last; };
230 /^2$/ && do{ if ($ftype == TType::I32) {
231 $xfer += $input->readI32(\$self->{afterUSN});
232 } else {
233 $xfer += $input->skip($ftype);
234 }
235 last; };
236 /^3$/ && do{ if ($ftype == TType::I32) {
237 $xfer += $input->readI32(\$self->{maxEntries});
238 } else {
239 $xfer += $input->skip($ftype);
240 }
241 last; };
242 /^4$/ && do{ if ($ftype == TType::BOOL) {
243 $xfer += $input->readBool(\$self->{fullSyncOnly});
244 } else {
245 $xfer += $input->skip($ftype);
246 }
247 last; };
248 $xfer += $input->skip($ftype);
249 }
250 $xfer += $input->readFieldEnd();
251 }
252 $xfer += $input->readStructEnd();
253 return $xfer;
254 }
255  
256 sub write {
257 my ($self, $output) = @_;
258 my $xfer = 0;
259 $xfer += $output->writeStructBegin('NoteStore_getSyncChunk_args');
260 if (defined $self->{authenticationToken}) {
261 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
262 $xfer += $output->writeString($self->{authenticationToken});
263 $xfer += $output->writeFieldEnd();
264 }
265 if (defined $self->{afterUSN}) {
266 $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 2);
267 $xfer += $output->writeI32($self->{afterUSN});
268 $xfer += $output->writeFieldEnd();
269 }
270 if (defined $self->{maxEntries}) {
271 $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 3);
272 $xfer += $output->writeI32($self->{maxEntries});
273 $xfer += $output->writeFieldEnd();
274 }
275 if (defined $self->{fullSyncOnly}) {
276 $xfer += $output->writeFieldBegin('fullSyncOnly', TType::BOOL, 4);
277 $xfer += $output->writeBool($self->{fullSyncOnly});
278 $xfer += $output->writeFieldEnd();
279 }
280 $xfer += $output->writeFieldStop();
281 $xfer += $output->writeStructEnd();
282 return $xfer;
283 }
284  
285 package Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result;
286 use base qw(Class::Accessor);
287 Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->mk_accessors( qw( success ) );
288  
289 sub new {
290 my $classname = shift;
291 my $self = {};
292 my $vals = shift || {};
293 $self->{success} = undef;
294 $self->{userException} = undef;
295 $self->{systemException} = undef;
296 if (UNIVERSAL::isa($vals,'HASH')) {
297 if (defined $vals->{success}) {
298 $self->{success} = $vals->{success};
299 }
300 if (defined $vals->{userException}) {
301 $self->{userException} = $vals->{userException};
302 }
303 if (defined $vals->{systemException}) {
304 $self->{systemException} = $vals->{systemException};
305 }
306 }
307 return bless ($self, $classname);
308 }
309  
310 sub getName {
311 return 'NoteStore_getSyncChunk_result';
312 }
313  
314 sub read {
315 my ($self, $input) = @_;
316 my $xfer = 0;
317 my $fname;
318 my $ftype = 0;
319 my $fid = 0;
320 $xfer += $input->readStructBegin(\$fname);
321 while (1)
322 {
323 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
324 if ($ftype == TType::STOP) {
325 last;
326 }
327 SWITCH: for($fid)
328 {
329 /^0$/ && do{ if ($ftype == TType::STRUCT) {
330 $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
331 $xfer += $self->{success}->read($input);
332 } else {
333 $xfer += $input->skip($ftype);
334 }
335 last; };
336 /^1$/ && do{ if ($ftype == TType::STRUCT) {
337 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
338 $xfer += $self->{userException}->read($input);
339 } else {
340 $xfer += $input->skip($ftype);
341 }
342 last; };
343 /^2$/ && do{ if ($ftype == TType::STRUCT) {
344 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
345 $xfer += $self->{systemException}->read($input);
346 } else {
347 $xfer += $input->skip($ftype);
348 }
349 last; };
350 $xfer += $input->skip($ftype);
351 }
352 $xfer += $input->readFieldEnd();
353 }
354 $xfer += $input->readStructEnd();
355 return $xfer;
356 }
357  
358 sub write {
359 my ($self, $output) = @_;
360 my $xfer = 0;
361 $xfer += $output->writeStructBegin('NoteStore_getSyncChunk_result');
362 if (defined $self->{success}) {
363 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
364 $xfer += $self->{success}->write($output);
365 $xfer += $output->writeFieldEnd();
366 }
367 if (defined $self->{userException}) {
368 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
369 $xfer += $self->{userException}->write($output);
370 $xfer += $output->writeFieldEnd();
371 }
372 if (defined $self->{systemException}) {
373 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
374 $xfer += $self->{systemException}->write($output);
375 $xfer += $output->writeFieldEnd();
376 }
377 $xfer += $output->writeFieldStop();
378 $xfer += $output->writeStructEnd();
379 return $xfer;
380 }
381  
382 package Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args;
383 use base qw(Class::Accessor);
384 Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->mk_accessors( qw( authenticationToken afterUSN maxEntries filter ) );
385  
386 sub new {
387 my $classname = shift;
388 my $self = {};
389 my $vals = shift || {};
390 $self->{authenticationToken} = undef;
391 $self->{afterUSN} = undef;
392 $self->{maxEntries} = undef;
393 $self->{filter} = undef;
394 if (UNIVERSAL::isa($vals,'HASH')) {
395 if (defined $vals->{authenticationToken}) {
396 $self->{authenticationToken} = $vals->{authenticationToken};
397 }
398 if (defined $vals->{afterUSN}) {
399 $self->{afterUSN} = $vals->{afterUSN};
400 }
401 if (defined $vals->{maxEntries}) {
402 $self->{maxEntries} = $vals->{maxEntries};
403 }
404 if (defined $vals->{filter}) {
405 $self->{filter} = $vals->{filter};
406 }
407 }
408 return bless ($self, $classname);
409 }
410  
411 sub getName {
412 return 'NoteStore_getFilteredSyncChunk_args';
413 }
414  
415 sub read {
416 my ($self, $input) = @_;
417 my $xfer = 0;
418 my $fname;
419 my $ftype = 0;
420 my $fid = 0;
421 $xfer += $input->readStructBegin(\$fname);
422 while (1)
423 {
424 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
425 if ($ftype == TType::STOP) {
426 last;
427 }
428 SWITCH: for($fid)
429 {
430 /^1$/ && do{ if ($ftype == TType::STRING) {
431 $xfer += $input->readString(\$self->{authenticationToken});
432 } else {
433 $xfer += $input->skip($ftype);
434 }
435 last; };
436 /^2$/ && do{ if ($ftype == TType::I32) {
437 $xfer += $input->readI32(\$self->{afterUSN});
438 } else {
439 $xfer += $input->skip($ftype);
440 }
441 last; };
442 /^3$/ && do{ if ($ftype == TType::I32) {
443 $xfer += $input->readI32(\$self->{maxEntries});
444 } else {
445 $xfer += $input->skip($ftype);
446 }
447 last; };
448 /^4$/ && do{ if ($ftype == TType::STRUCT) {
449 $self->{filter} = Net::Evernote::EDAMNoteStore::SyncChunkFilter->new();
450 $xfer += $self->{filter}->read($input);
451 } else {
452 $xfer += $input->skip($ftype);
453 }
454 last; };
455 $xfer += $input->skip($ftype);
456 }
457 $xfer += $input->readFieldEnd();
458 }
459 $xfer += $input->readStructEnd();
460 return $xfer;
461 }
462  
463 sub write {
464 my ($self, $output) = @_;
465 my $xfer = 0;
466 $xfer += $output->writeStructBegin('NoteStore_getFilteredSyncChunk_args');
467 if (defined $self->{authenticationToken}) {
468 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
469 $xfer += $output->writeString($self->{authenticationToken});
470 $xfer += $output->writeFieldEnd();
471 }
472 if (defined $self->{afterUSN}) {
473 $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 2);
474 $xfer += $output->writeI32($self->{afterUSN});
475 $xfer += $output->writeFieldEnd();
476 }
477 if (defined $self->{maxEntries}) {
478 $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 3);
479 $xfer += $output->writeI32($self->{maxEntries});
480 $xfer += $output->writeFieldEnd();
481 }
482 if (defined $self->{filter}) {
483 $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 4);
484 $xfer += $self->{filter}->write($output);
485 $xfer += $output->writeFieldEnd();
486 }
487 $xfer += $output->writeFieldStop();
488 $xfer += $output->writeStructEnd();
489 return $xfer;
490 }
491  
492 package Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result;
493 use base qw(Class::Accessor);
494 Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->mk_accessors( qw( success ) );
495  
496 sub new {
497 my $classname = shift;
498 my $self = {};
499 my $vals = shift || {};
500 $self->{success} = undef;
501 $self->{userException} = undef;
502 $self->{systemException} = undef;
503 if (UNIVERSAL::isa($vals,'HASH')) {
504 if (defined $vals->{success}) {
505 $self->{success} = $vals->{success};
506 }
507 if (defined $vals->{userException}) {
508 $self->{userException} = $vals->{userException};
509 }
510 if (defined $vals->{systemException}) {
511 $self->{systemException} = $vals->{systemException};
512 }
513 }
514 return bless ($self, $classname);
515 }
516  
517 sub getName {
518 return 'NoteStore_getFilteredSyncChunk_result';
519 }
520  
521 sub read {
522 my ($self, $input) = @_;
523 my $xfer = 0;
524 my $fname;
525 my $ftype = 0;
526 my $fid = 0;
527 $xfer += $input->readStructBegin(\$fname);
528 while (1)
529 {
530 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
531 if ($ftype == TType::STOP) {
532 last;
533 }
534 SWITCH: for($fid)
535 {
536 /^0$/ && do{ if ($ftype == TType::STRUCT) {
537 $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
538 $xfer += $self->{success}->read($input);
539 } else {
540 $xfer += $input->skip($ftype);
541 }
542 last; };
543 /^1$/ && do{ if ($ftype == TType::STRUCT) {
544 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
545 $xfer += $self->{userException}->read($input);
546 } else {
547 $xfer += $input->skip($ftype);
548 }
549 last; };
550 /^2$/ && do{ if ($ftype == TType::STRUCT) {
551 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
552 $xfer += $self->{systemException}->read($input);
553 } else {
554 $xfer += $input->skip($ftype);
555 }
556 last; };
557 $xfer += $input->skip($ftype);
558 }
559 $xfer += $input->readFieldEnd();
560 }
561 $xfer += $input->readStructEnd();
562 return $xfer;
563 }
564  
565 sub write {
566 my ($self, $output) = @_;
567 my $xfer = 0;
568 $xfer += $output->writeStructBegin('NoteStore_getFilteredSyncChunk_result');
569 if (defined $self->{success}) {
570 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
571 $xfer += $self->{success}->write($output);
572 $xfer += $output->writeFieldEnd();
573 }
574 if (defined $self->{userException}) {
575 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
576 $xfer += $self->{userException}->write($output);
577 $xfer += $output->writeFieldEnd();
578 }
579 if (defined $self->{systemException}) {
580 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
581 $xfer += $self->{systemException}->write($output);
582 $xfer += $output->writeFieldEnd();
583 }
584 $xfer += $output->writeFieldStop();
585 $xfer += $output->writeStructEnd();
586 return $xfer;
587 }
588  
589 package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args;
590 use base qw(Class::Accessor);
591 Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->mk_accessors( qw( authenticationToken linkedNotebook ) );
592  
593 sub new {
594 my $classname = shift;
595 my $self = {};
596 my $vals = shift || {};
597 $self->{authenticationToken} = undef;
598 $self->{linkedNotebook} = undef;
599 if (UNIVERSAL::isa($vals,'HASH')) {
600 if (defined $vals->{authenticationToken}) {
601 $self->{authenticationToken} = $vals->{authenticationToken};
602 }
603 if (defined $vals->{linkedNotebook}) {
604 $self->{linkedNotebook} = $vals->{linkedNotebook};
605 }
606 }
607 return bless ($self, $classname);
608 }
609  
610 sub getName {
611 return 'NoteStore_getLinkedNotebookSyncState_args';
612 }
613  
614 sub read {
615 my ($self, $input) = @_;
616 my $xfer = 0;
617 my $fname;
618 my $ftype = 0;
619 my $fid = 0;
620 $xfer += $input->readStructBegin(\$fname);
621 while (1)
622 {
623 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
624 if ($ftype == TType::STOP) {
625 last;
626 }
627 SWITCH: for($fid)
628 {
629 /^1$/ && do{ if ($ftype == TType::STRING) {
630 $xfer += $input->readString(\$self->{authenticationToken});
631 } else {
632 $xfer += $input->skip($ftype);
633 }
634 last; };
635 /^2$/ && do{ if ($ftype == TType::STRUCT) {
636 $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
637 $xfer += $self->{linkedNotebook}->read($input);
638 } else {
639 $xfer += $input->skip($ftype);
640 }
641 last; };
642 $xfer += $input->skip($ftype);
643 }
644 $xfer += $input->readFieldEnd();
645 }
646 $xfer += $input->readStructEnd();
647 return $xfer;
648 }
649  
650 sub write {
651 my ($self, $output) = @_;
652 my $xfer = 0;
653 $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncState_args');
654 if (defined $self->{authenticationToken}) {
655 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
656 $xfer += $output->writeString($self->{authenticationToken});
657 $xfer += $output->writeFieldEnd();
658 }
659 if (defined $self->{linkedNotebook}) {
660 $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
661 $xfer += $self->{linkedNotebook}->write($output);
662 $xfer += $output->writeFieldEnd();
663 }
664 $xfer += $output->writeFieldStop();
665 $xfer += $output->writeStructEnd();
666 return $xfer;
667 }
668  
669 package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result;
670 use base qw(Class::Accessor);
671 Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->mk_accessors( qw( success ) );
672  
673 sub new {
674 my $classname = shift;
675 my $self = {};
676 my $vals = shift || {};
677 $self->{success} = undef;
678 $self->{userException} = undef;
679 $self->{systemException} = undef;
680 $self->{notFoundException} = undef;
681 if (UNIVERSAL::isa($vals,'HASH')) {
682 if (defined $vals->{success}) {
683 $self->{success} = $vals->{success};
684 }
685 if (defined $vals->{userException}) {
686 $self->{userException} = $vals->{userException};
687 }
688 if (defined $vals->{systemException}) {
689 $self->{systemException} = $vals->{systemException};
690 }
691 if (defined $vals->{notFoundException}) {
692 $self->{notFoundException} = $vals->{notFoundException};
693 }
694 }
695 return bless ($self, $classname);
696 }
697  
698 sub getName {
699 return 'NoteStore_getLinkedNotebookSyncState_result';
700 }
701  
702 sub read {
703 my ($self, $input) = @_;
704 my $xfer = 0;
705 my $fname;
706 my $ftype = 0;
707 my $fid = 0;
708 $xfer += $input->readStructBegin(\$fname);
709 while (1)
710 {
711 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
712 if ($ftype == TType::STOP) {
713 last;
714 }
715 SWITCH: for($fid)
716 {
717 /^0$/ && do{ if ($ftype == TType::STRUCT) {
718 $self->{success} = Net::Evernote::EDAMNoteStore::SyncState->new();
719 $xfer += $self->{success}->read($input);
720 } else {
721 $xfer += $input->skip($ftype);
722 }
723 last; };
724 /^1$/ && do{ if ($ftype == TType::STRUCT) {
725 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
726 $xfer += $self->{userException}->read($input);
727 } else {
728 $xfer += $input->skip($ftype);
729 }
730 last; };
731 /^2$/ && do{ if ($ftype == TType::STRUCT) {
732 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
733 $xfer += $self->{systemException}->read($input);
734 } else {
735 $xfer += $input->skip($ftype);
736 }
737 last; };
738 /^3$/ && do{ if ($ftype == TType::STRUCT) {
739 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
740 $xfer += $self->{notFoundException}->read($input);
741 } else {
742 $xfer += $input->skip($ftype);
743 }
744 last; };
745 $xfer += $input->skip($ftype);
746 }
747 $xfer += $input->readFieldEnd();
748 }
749 $xfer += $input->readStructEnd();
750 return $xfer;
751 }
752  
753 sub write {
754 my ($self, $output) = @_;
755 my $xfer = 0;
756 $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncState_result');
757 if (defined $self->{success}) {
758 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
759 $xfer += $self->{success}->write($output);
760 $xfer += $output->writeFieldEnd();
761 }
762 if (defined $self->{userException}) {
763 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
764 $xfer += $self->{userException}->write($output);
765 $xfer += $output->writeFieldEnd();
766 }
767 if (defined $self->{systemException}) {
768 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
769 $xfer += $self->{systemException}->write($output);
770 $xfer += $output->writeFieldEnd();
771 }
772 if (defined $self->{notFoundException}) {
773 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
774 $xfer += $self->{notFoundException}->write($output);
775 $xfer += $output->writeFieldEnd();
776 }
777 $xfer += $output->writeFieldStop();
778 $xfer += $output->writeStructEnd();
779 return $xfer;
780 }
781  
782 package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args;
783 use base qw(Class::Accessor);
784 Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->mk_accessors( qw( authenticationToken linkedNotebook afterUSN maxEntries fullSyncOnly ) );
785  
786 sub new {
787 my $classname = shift;
788 my $self = {};
789 my $vals = shift || {};
790 $self->{authenticationToken} = undef;
791 $self->{linkedNotebook} = undef;
792 $self->{afterUSN} = undef;
793 $self->{maxEntries} = undef;
794 $self->{fullSyncOnly} = undef;
795 if (UNIVERSAL::isa($vals,'HASH')) {
796 if (defined $vals->{authenticationToken}) {
797 $self->{authenticationToken} = $vals->{authenticationToken};
798 }
799 if (defined $vals->{linkedNotebook}) {
800 $self->{linkedNotebook} = $vals->{linkedNotebook};
801 }
802 if (defined $vals->{afterUSN}) {
803 $self->{afterUSN} = $vals->{afterUSN};
804 }
805 if (defined $vals->{maxEntries}) {
806 $self->{maxEntries} = $vals->{maxEntries};
807 }
808 if (defined $vals->{fullSyncOnly}) {
809 $self->{fullSyncOnly} = $vals->{fullSyncOnly};
810 }
811 }
812 return bless ($self, $classname);
813 }
814  
815 sub getName {
816 return 'NoteStore_getLinkedNotebookSyncChunk_args';
817 }
818  
819 sub read {
820 my ($self, $input) = @_;
821 my $xfer = 0;
822 my $fname;
823 my $ftype = 0;
824 my $fid = 0;
825 $xfer += $input->readStructBegin(\$fname);
826 while (1)
827 {
828 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
829 if ($ftype == TType::STOP) {
830 last;
831 }
832 SWITCH: for($fid)
833 {
834 /^1$/ && do{ if ($ftype == TType::STRING) {
835 $xfer += $input->readString(\$self->{authenticationToken});
836 } else {
837 $xfer += $input->skip($ftype);
838 }
839 last; };
840 /^2$/ && do{ if ($ftype == TType::STRUCT) {
841 $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
842 $xfer += $self->{linkedNotebook}->read($input);
843 } else {
844 $xfer += $input->skip($ftype);
845 }
846 last; };
847 /^3$/ && do{ if ($ftype == TType::I32) {
848 $xfer += $input->readI32(\$self->{afterUSN});
849 } else {
850 $xfer += $input->skip($ftype);
851 }
852 last; };
853 /^4$/ && do{ if ($ftype == TType::I32) {
854 $xfer += $input->readI32(\$self->{maxEntries});
855 } else {
856 $xfer += $input->skip($ftype);
857 }
858 last; };
859 /^5$/ && do{ if ($ftype == TType::BOOL) {
860 $xfer += $input->readBool(\$self->{fullSyncOnly});
861 } else {
862 $xfer += $input->skip($ftype);
863 }
864 last; };
865 $xfer += $input->skip($ftype);
866 }
867 $xfer += $input->readFieldEnd();
868 }
869 $xfer += $input->readStructEnd();
870 return $xfer;
871 }
872  
873 sub write {
874 my ($self, $output) = @_;
875 my $xfer = 0;
876 $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncChunk_args');
877 if (defined $self->{authenticationToken}) {
878 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
879 $xfer += $output->writeString($self->{authenticationToken});
880 $xfer += $output->writeFieldEnd();
881 }
882 if (defined $self->{linkedNotebook}) {
883 $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
884 $xfer += $self->{linkedNotebook}->write($output);
885 $xfer += $output->writeFieldEnd();
886 }
887 if (defined $self->{afterUSN}) {
888 $xfer += $output->writeFieldBegin('afterUSN', TType::I32, 3);
889 $xfer += $output->writeI32($self->{afterUSN});
890 $xfer += $output->writeFieldEnd();
891 }
892 if (defined $self->{maxEntries}) {
893 $xfer += $output->writeFieldBegin('maxEntries', TType::I32, 4);
894 $xfer += $output->writeI32($self->{maxEntries});
895 $xfer += $output->writeFieldEnd();
896 }
897 if (defined $self->{fullSyncOnly}) {
898 $xfer += $output->writeFieldBegin('fullSyncOnly', TType::BOOL, 5);
899 $xfer += $output->writeBool($self->{fullSyncOnly});
900 $xfer += $output->writeFieldEnd();
901 }
902 $xfer += $output->writeFieldStop();
903 $xfer += $output->writeStructEnd();
904 return $xfer;
905 }
906  
907 package Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result;
908 use base qw(Class::Accessor);
909 Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->mk_accessors( qw( success ) );
910  
911 sub new {
912 my $classname = shift;
913 my $self = {};
914 my $vals = shift || {};
915 $self->{success} = undef;
916 $self->{userException} = undef;
917 $self->{systemException} = undef;
918 $self->{notFoundException} = undef;
919 if (UNIVERSAL::isa($vals,'HASH')) {
920 if (defined $vals->{success}) {
921 $self->{success} = $vals->{success};
922 }
923 if (defined $vals->{userException}) {
924 $self->{userException} = $vals->{userException};
925 }
926 if (defined $vals->{systemException}) {
927 $self->{systemException} = $vals->{systemException};
928 }
929 if (defined $vals->{notFoundException}) {
930 $self->{notFoundException} = $vals->{notFoundException};
931 }
932 }
933 return bless ($self, $classname);
934 }
935  
936 sub getName {
937 return 'NoteStore_getLinkedNotebookSyncChunk_result';
938 }
939  
940 sub read {
941 my ($self, $input) = @_;
942 my $xfer = 0;
943 my $fname;
944 my $ftype = 0;
945 my $fid = 0;
946 $xfer += $input->readStructBegin(\$fname);
947 while (1)
948 {
949 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
950 if ($ftype == TType::STOP) {
951 last;
952 }
953 SWITCH: for($fid)
954 {
955 /^0$/ && do{ if ($ftype == TType::STRUCT) {
956 $self->{success} = Net::Evernote::EDAMNoteStore::SyncChunk->new();
957 $xfer += $self->{success}->read($input);
958 } else {
959 $xfer += $input->skip($ftype);
960 }
961 last; };
962 /^1$/ && do{ if ($ftype == TType::STRUCT) {
963 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
964 $xfer += $self->{userException}->read($input);
965 } else {
966 $xfer += $input->skip($ftype);
967 }
968 last; };
969 /^2$/ && do{ if ($ftype == TType::STRUCT) {
970 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
971 $xfer += $self->{systemException}->read($input);
972 } else {
973 $xfer += $input->skip($ftype);
974 }
975 last; };
976 /^3$/ && do{ if ($ftype == TType::STRUCT) {
977 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
978 $xfer += $self->{notFoundException}->read($input);
979 } else {
980 $xfer += $input->skip($ftype);
981 }
982 last; };
983 $xfer += $input->skip($ftype);
984 }
985 $xfer += $input->readFieldEnd();
986 }
987 $xfer += $input->readStructEnd();
988 return $xfer;
989 }
990  
991 sub write {
992 my ($self, $output) = @_;
993 my $xfer = 0;
994 $xfer += $output->writeStructBegin('NoteStore_getLinkedNotebookSyncChunk_result');
995 if (defined $self->{success}) {
996 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
997 $xfer += $self->{success}->write($output);
998 $xfer += $output->writeFieldEnd();
999 }
1000 if (defined $self->{userException}) {
1001 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1002 $xfer += $self->{userException}->write($output);
1003 $xfer += $output->writeFieldEnd();
1004 }
1005 if (defined $self->{systemException}) {
1006 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1007 $xfer += $self->{systemException}->write($output);
1008 $xfer += $output->writeFieldEnd();
1009 }
1010 if (defined $self->{notFoundException}) {
1011 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
1012 $xfer += $self->{notFoundException}->write($output);
1013 $xfer += $output->writeFieldEnd();
1014 }
1015 $xfer += $output->writeFieldStop();
1016 $xfer += $output->writeStructEnd();
1017 return $xfer;
1018 }
1019  
1020 package Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args;
1021 use base qw(Class::Accessor);
1022 Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->mk_accessors( qw( authenticationToken ) );
1023  
1024 sub new {
1025 my $classname = shift;
1026 my $self = {};
1027 my $vals = shift || {};
1028 $self->{authenticationToken} = undef;
1029 if (UNIVERSAL::isa($vals,'HASH')) {
1030 if (defined $vals->{authenticationToken}) {
1031 $self->{authenticationToken} = $vals->{authenticationToken};
1032 }
1033 }
1034 return bless ($self, $classname);
1035 }
1036  
1037 sub getName {
1038 return 'NoteStore_listNotebooks_args';
1039 }
1040  
1041 sub read {
1042 my ($self, $input) = @_;
1043 my $xfer = 0;
1044 my $fname;
1045 my $ftype = 0;
1046 my $fid = 0;
1047 $xfer += $input->readStructBegin(\$fname);
1048 while (1)
1049 {
1050 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1051 if ($ftype == TType::STOP) {
1052 last;
1053 }
1054 SWITCH: for($fid)
1055 {
1056 /^1$/ && do{ if ($ftype == TType::STRING) {
1057 $xfer += $input->readString(\$self->{authenticationToken});
1058 } else {
1059 $xfer += $input->skip($ftype);
1060 }
1061 last; };
1062 $xfer += $input->skip($ftype);
1063 }
1064 $xfer += $input->readFieldEnd();
1065 }
1066 $xfer += $input->readStructEnd();
1067 return $xfer;
1068 }
1069  
1070 sub write {
1071 my ($self, $output) = @_;
1072 my $xfer = 0;
1073 $xfer += $output->writeStructBegin('NoteStore_listNotebooks_args');
1074 if (defined $self->{authenticationToken}) {
1075 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1076 $xfer += $output->writeString($self->{authenticationToken});
1077 $xfer += $output->writeFieldEnd();
1078 }
1079 $xfer += $output->writeFieldStop();
1080 $xfer += $output->writeStructEnd();
1081 return $xfer;
1082 }
1083  
1084 package Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result;
1085 use base qw(Class::Accessor);
1086 Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->mk_accessors( qw( success ) );
1087  
1088 sub new {
1089 my $classname = shift;
1090 my $self = {};
1091 my $vals = shift || {};
1092 $self->{success} = undef;
1093 $self->{userException} = undef;
1094 $self->{systemException} = undef;
1095 if (UNIVERSAL::isa($vals,'HASH')) {
1096 if (defined $vals->{success}) {
1097 $self->{success} = $vals->{success};
1098 }
1099 if (defined $vals->{userException}) {
1100 $self->{userException} = $vals->{userException};
1101 }
1102 if (defined $vals->{systemException}) {
1103 $self->{systemException} = $vals->{systemException};
1104 }
1105 }
1106 return bless ($self, $classname);
1107 }
1108  
1109 sub getName {
1110 return 'NoteStore_listNotebooks_result';
1111 }
1112  
1113 sub read {
1114 my ($self, $input) = @_;
1115 my $xfer = 0;
1116 my $fname;
1117 my $ftype = 0;
1118 my $fid = 0;
1119 $xfer += $input->readStructBegin(\$fname);
1120 while (1)
1121 {
1122 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1123 if ($ftype == TType::STOP) {
1124 last;
1125 }
1126 SWITCH: for($fid)
1127 {
1128 /^0$/ && do{ if ($ftype == TType::LIST) {
1129 {
1130 my $_size181 = 0;
1131 $self->{success} = [];
1132 my $_etype184 = 0;
1133 $xfer += $input->readListBegin(\$_etype184, \$_size181);
1134 for (my $_i185 = 0; $_i185 < $_size181; ++$_i185)
1135 {
1136 my $elem186 = undef;
1137 $elem186 = Net::Evernote::EDAMTypes::Notebook->new();
1138 $xfer += $elem186->read($input);
1139 push(@{$self->{success}},$elem186);
1140 }
1141 $xfer += $input->readListEnd();
1142 }
1143 } else {
1144 $xfer += $input->skip($ftype);
1145 }
1146 last; };
1147 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1148 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
1149 $xfer += $self->{userException}->read($input);
1150 } else {
1151 $xfer += $input->skip($ftype);
1152 }
1153 last; };
1154 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1155 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
1156 $xfer += $self->{systemException}->read($input);
1157 } else {
1158 $xfer += $input->skip($ftype);
1159 }
1160 last; };
1161 $xfer += $input->skip($ftype);
1162 }
1163 $xfer += $input->readFieldEnd();
1164 }
1165 $xfer += $input->readStructEnd();
1166 return $xfer;
1167 }
1168  
1169 sub write {
1170 my ($self, $output) = @_;
1171 my $xfer = 0;
1172 $xfer += $output->writeStructBegin('NoteStore_listNotebooks_result');
1173 if (defined $self->{success}) {
1174 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
1175 {
1176 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
1177 {
1178 foreach my $iter187 (@{$self->{success}})
1179 {
1180 $xfer += ${iter187}->write($output);
1181 }
1182 }
1183 $xfer += $output->writeListEnd();
1184 }
1185 $xfer += $output->writeFieldEnd();
1186 }
1187 if (defined $self->{userException}) {
1188 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1189 $xfer += $self->{userException}->write($output);
1190 $xfer += $output->writeFieldEnd();
1191 }
1192 if (defined $self->{systemException}) {
1193 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1194 $xfer += $self->{systemException}->write($output);
1195 $xfer += $output->writeFieldEnd();
1196 }
1197 $xfer += $output->writeFieldStop();
1198 $xfer += $output->writeStructEnd();
1199 return $xfer;
1200 }
1201  
1202 package Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args;
1203 use base qw(Class::Accessor);
1204 Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->mk_accessors( qw( authenticationToken guid ) );
1205  
1206 sub new {
1207 my $classname = shift;
1208 my $self = {};
1209 my $vals = shift || {};
1210 $self->{authenticationToken} = undef;
1211 $self->{guid} = undef;
1212 if (UNIVERSAL::isa($vals,'HASH')) {
1213 if (defined $vals->{authenticationToken}) {
1214 $self->{authenticationToken} = $vals->{authenticationToken};
1215 }
1216 if (defined $vals->{guid}) {
1217 $self->{guid} = $vals->{guid};
1218 }
1219 }
1220 return bless ($self, $classname);
1221 }
1222  
1223 sub getName {
1224 return 'NoteStore_getNotebook_args';
1225 }
1226  
1227 sub read {
1228 my ($self, $input) = @_;
1229 my $xfer = 0;
1230 my $fname;
1231 my $ftype = 0;
1232 my $fid = 0;
1233 $xfer += $input->readStructBegin(\$fname);
1234 while (1)
1235 {
1236 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1237 if ($ftype == TType::STOP) {
1238 last;
1239 }
1240 SWITCH: for($fid)
1241 {
1242 /^1$/ && do{ if ($ftype == TType::STRING) {
1243 $xfer += $input->readString(\$self->{authenticationToken});
1244 } else {
1245 $xfer += $input->skip($ftype);
1246 }
1247 last; };
1248 /^2$/ && do{ if ($ftype == TType::STRING) {
1249 $xfer += $input->readString(\$self->{guid});
1250 } else {
1251 $xfer += $input->skip($ftype);
1252 }
1253 last; };
1254 $xfer += $input->skip($ftype);
1255 }
1256 $xfer += $input->readFieldEnd();
1257 }
1258 $xfer += $input->readStructEnd();
1259 return $xfer;
1260 }
1261  
1262 sub write {
1263 my ($self, $output) = @_;
1264 my $xfer = 0;
1265 $xfer += $output->writeStructBegin('NoteStore_getNotebook_args');
1266 if (defined $self->{authenticationToken}) {
1267 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1268 $xfer += $output->writeString($self->{authenticationToken});
1269 $xfer += $output->writeFieldEnd();
1270 }
1271 if (defined $self->{guid}) {
1272 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
1273 $xfer += $output->writeString($self->{guid});
1274 $xfer += $output->writeFieldEnd();
1275 }
1276 $xfer += $output->writeFieldStop();
1277 $xfer += $output->writeStructEnd();
1278 return $xfer;
1279 }
1280  
1281 package Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result;
1282 use base qw(Class::Accessor);
1283 Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->mk_accessors( qw( success ) );
1284  
1285 sub new {
1286 my $classname = shift;
1287 my $self = {};
1288 my $vals = shift || {};
1289 $self->{success} = undef;
1290 $self->{userException} = undef;
1291 $self->{systemException} = undef;
1292 $self->{notFoundException} = undef;
1293 if (UNIVERSAL::isa($vals,'HASH')) {
1294 if (defined $vals->{success}) {
1295 $self->{success} = $vals->{success};
1296 }
1297 if (defined $vals->{userException}) {
1298 $self->{userException} = $vals->{userException};
1299 }
1300 if (defined $vals->{systemException}) {
1301 $self->{systemException} = $vals->{systemException};
1302 }
1303 if (defined $vals->{notFoundException}) {
1304 $self->{notFoundException} = $vals->{notFoundException};
1305 }
1306 }
1307 return bless ($self, $classname);
1308 }
1309  
1310 sub getName {
1311 return 'NoteStore_getNotebook_result';
1312 }
1313  
1314 sub read {
1315 my ($self, $input) = @_;
1316 my $xfer = 0;
1317 my $fname;
1318 my $ftype = 0;
1319 my $fid = 0;
1320 $xfer += $input->readStructBegin(\$fname);
1321 while (1)
1322 {
1323 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1324 if ($ftype == TType::STOP) {
1325 last;
1326 }
1327 SWITCH: for($fid)
1328 {
1329 /^0$/ && do{ if ($ftype == TType::STRUCT) {
1330 $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
1331 $xfer += $self->{success}->read($input);
1332 } else {
1333 $xfer += $input->skip($ftype);
1334 }
1335 last; };
1336 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1337 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
1338 $xfer += $self->{userException}->read($input);
1339 } else {
1340 $xfer += $input->skip($ftype);
1341 }
1342 last; };
1343 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1344 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
1345 $xfer += $self->{systemException}->read($input);
1346 } else {
1347 $xfer += $input->skip($ftype);
1348 }
1349 last; };
1350 /^3$/ && do{ if ($ftype == TType::STRUCT) {
1351 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
1352 $xfer += $self->{notFoundException}->read($input);
1353 } else {
1354 $xfer += $input->skip($ftype);
1355 }
1356 last; };
1357 $xfer += $input->skip($ftype);
1358 }
1359 $xfer += $input->readFieldEnd();
1360 }
1361 $xfer += $input->readStructEnd();
1362 return $xfer;
1363 }
1364  
1365 sub write {
1366 my ($self, $output) = @_;
1367 my $xfer = 0;
1368 $xfer += $output->writeStructBegin('NoteStore_getNotebook_result');
1369 if (defined $self->{success}) {
1370 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1371 $xfer += $self->{success}->write($output);
1372 $xfer += $output->writeFieldEnd();
1373 }
1374 if (defined $self->{userException}) {
1375 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1376 $xfer += $self->{userException}->write($output);
1377 $xfer += $output->writeFieldEnd();
1378 }
1379 if (defined $self->{systemException}) {
1380 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1381 $xfer += $self->{systemException}->write($output);
1382 $xfer += $output->writeFieldEnd();
1383 }
1384 if (defined $self->{notFoundException}) {
1385 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
1386 $xfer += $self->{notFoundException}->write($output);
1387 $xfer += $output->writeFieldEnd();
1388 }
1389 $xfer += $output->writeFieldStop();
1390 $xfer += $output->writeStructEnd();
1391 return $xfer;
1392 }
1393  
1394 package Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args;
1395 use base qw(Class::Accessor);
1396 Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->mk_accessors( qw( authenticationToken ) );
1397  
1398 sub new {
1399 my $classname = shift;
1400 my $self = {};
1401 my $vals = shift || {};
1402 $self->{authenticationToken} = undef;
1403 if (UNIVERSAL::isa($vals,'HASH')) {
1404 if (defined $vals->{authenticationToken}) {
1405 $self->{authenticationToken} = $vals->{authenticationToken};
1406 }
1407 }
1408 return bless ($self, $classname);
1409 }
1410  
1411 sub getName {
1412 return 'NoteStore_getDefaultNotebook_args';
1413 }
1414  
1415 sub read {
1416 my ($self, $input) = @_;
1417 my $xfer = 0;
1418 my $fname;
1419 my $ftype = 0;
1420 my $fid = 0;
1421 $xfer += $input->readStructBegin(\$fname);
1422 while (1)
1423 {
1424 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1425 if ($ftype == TType::STOP) {
1426 last;
1427 }
1428 SWITCH: for($fid)
1429 {
1430 /^1$/ && do{ if ($ftype == TType::STRING) {
1431 $xfer += $input->readString(\$self->{authenticationToken});
1432 } else {
1433 $xfer += $input->skip($ftype);
1434 }
1435 last; };
1436 $xfer += $input->skip($ftype);
1437 }
1438 $xfer += $input->readFieldEnd();
1439 }
1440 $xfer += $input->readStructEnd();
1441 return $xfer;
1442 }
1443  
1444 sub write {
1445 my ($self, $output) = @_;
1446 my $xfer = 0;
1447 $xfer += $output->writeStructBegin('NoteStore_getDefaultNotebook_args');
1448 if (defined $self->{authenticationToken}) {
1449 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1450 $xfer += $output->writeString($self->{authenticationToken});
1451 $xfer += $output->writeFieldEnd();
1452 }
1453 $xfer += $output->writeFieldStop();
1454 $xfer += $output->writeStructEnd();
1455 return $xfer;
1456 }
1457  
1458 package Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result;
1459 use base qw(Class::Accessor);
1460 Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->mk_accessors( qw( success ) );
1461  
1462 sub new {
1463 my $classname = shift;
1464 my $self = {};
1465 my $vals = shift || {};
1466 $self->{success} = undef;
1467 $self->{userException} = undef;
1468 $self->{systemException} = undef;
1469 if (UNIVERSAL::isa($vals,'HASH')) {
1470 if (defined $vals->{success}) {
1471 $self->{success} = $vals->{success};
1472 }
1473 if (defined $vals->{userException}) {
1474 $self->{userException} = $vals->{userException};
1475 }
1476 if (defined $vals->{systemException}) {
1477 $self->{systemException} = $vals->{systemException};
1478 }
1479 }
1480 return bless ($self, $classname);
1481 }
1482  
1483 sub getName {
1484 return 'NoteStore_getDefaultNotebook_result';
1485 }
1486  
1487 sub read {
1488 my ($self, $input) = @_;
1489 my $xfer = 0;
1490 my $fname;
1491 my $ftype = 0;
1492 my $fid = 0;
1493 $xfer += $input->readStructBegin(\$fname);
1494 while (1)
1495 {
1496 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1497 if ($ftype == TType::STOP) {
1498 last;
1499 }
1500 SWITCH: for($fid)
1501 {
1502 /^0$/ && do{ if ($ftype == TType::STRUCT) {
1503 $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
1504 $xfer += $self->{success}->read($input);
1505 } else {
1506 $xfer += $input->skip($ftype);
1507 }
1508 last; };
1509 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1510 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
1511 $xfer += $self->{userException}->read($input);
1512 } else {
1513 $xfer += $input->skip($ftype);
1514 }
1515 last; };
1516 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1517 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
1518 $xfer += $self->{systemException}->read($input);
1519 } else {
1520 $xfer += $input->skip($ftype);
1521 }
1522 last; };
1523 $xfer += $input->skip($ftype);
1524 }
1525 $xfer += $input->readFieldEnd();
1526 }
1527 $xfer += $input->readStructEnd();
1528 return $xfer;
1529 }
1530  
1531 sub write {
1532 my ($self, $output) = @_;
1533 my $xfer = 0;
1534 $xfer += $output->writeStructBegin('NoteStore_getDefaultNotebook_result');
1535 if (defined $self->{success}) {
1536 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1537 $xfer += $self->{success}->write($output);
1538 $xfer += $output->writeFieldEnd();
1539 }
1540 if (defined $self->{userException}) {
1541 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1542 $xfer += $self->{userException}->write($output);
1543 $xfer += $output->writeFieldEnd();
1544 }
1545 if (defined $self->{systemException}) {
1546 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1547 $xfer += $self->{systemException}->write($output);
1548 $xfer += $output->writeFieldEnd();
1549 }
1550 $xfer += $output->writeFieldStop();
1551 $xfer += $output->writeStructEnd();
1552 return $xfer;
1553 }
1554  
1555 package Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args;
1556 use base qw(Class::Accessor);
1557 Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->mk_accessors( qw( authenticationToken notebook ) );
1558  
1559 sub new {
1560 my $classname = shift;
1561 my $self = {};
1562 my $vals = shift || {};
1563 $self->{authenticationToken} = undef;
1564 $self->{notebook} = undef;
1565 if (UNIVERSAL::isa($vals,'HASH')) {
1566 if (defined $vals->{authenticationToken}) {
1567 $self->{authenticationToken} = $vals->{authenticationToken};
1568 }
1569 if (defined $vals->{notebook}) {
1570 $self->{notebook} = $vals->{notebook};
1571 }
1572 }
1573 return bless ($self, $classname);
1574 }
1575  
1576 sub getName {
1577 return 'NoteStore_createNotebook_args';
1578 }
1579  
1580 sub read {
1581 my ($self, $input) = @_;
1582 my $xfer = 0;
1583 my $fname;
1584 my $ftype = 0;
1585 my $fid = 0;
1586 $xfer += $input->readStructBegin(\$fname);
1587 while (1)
1588 {
1589 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1590 if ($ftype == TType::STOP) {
1591 last;
1592 }
1593 SWITCH: for($fid)
1594 {
1595 /^1$/ && do{ if ($ftype == TType::STRING) {
1596 $xfer += $input->readString(\$self->{authenticationToken});
1597 } else {
1598 $xfer += $input->skip($ftype);
1599 }
1600 last; };
1601 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1602 $self->{notebook} = Net::Evernote::EDAMTypes::Notebook->new();
1603 $xfer += $self->{notebook}->read($input);
1604 } else {
1605 $xfer += $input->skip($ftype);
1606 }
1607 last; };
1608 $xfer += $input->skip($ftype);
1609 }
1610 $xfer += $input->readFieldEnd();
1611 }
1612 $xfer += $input->readStructEnd();
1613 return $xfer;
1614 }
1615  
1616 sub write {
1617 my ($self, $output) = @_;
1618 my $xfer = 0;
1619 $xfer += $output->writeStructBegin('NoteStore_createNotebook_args');
1620 if (defined $self->{authenticationToken}) {
1621 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1622 $xfer += $output->writeString($self->{authenticationToken});
1623 $xfer += $output->writeFieldEnd();
1624 }
1625 if (defined $self->{notebook}) {
1626 $xfer += $output->writeFieldBegin('notebook', TType::STRUCT, 2);
1627 $xfer += $self->{notebook}->write($output);
1628 $xfer += $output->writeFieldEnd();
1629 }
1630 $xfer += $output->writeFieldStop();
1631 $xfer += $output->writeStructEnd();
1632 return $xfer;
1633 }
1634  
1635 package Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result;
1636 use base qw(Class::Accessor);
1637 Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->mk_accessors( qw( success ) );
1638  
1639 sub new {
1640 my $classname = shift;
1641 my $self = {};
1642 my $vals = shift || {};
1643 $self->{success} = undef;
1644 $self->{userException} = undef;
1645 $self->{systemException} = undef;
1646 if (UNIVERSAL::isa($vals,'HASH')) {
1647 if (defined $vals->{success}) {
1648 $self->{success} = $vals->{success};
1649 }
1650 if (defined $vals->{userException}) {
1651 $self->{userException} = $vals->{userException};
1652 }
1653 if (defined $vals->{systemException}) {
1654 $self->{systemException} = $vals->{systemException};
1655 }
1656 }
1657 return bless ($self, $classname);
1658 }
1659  
1660 sub getName {
1661 return 'NoteStore_createNotebook_result';
1662 }
1663  
1664 sub read {
1665 my ($self, $input) = @_;
1666 my $xfer = 0;
1667 my $fname;
1668 my $ftype = 0;
1669 my $fid = 0;
1670 $xfer += $input->readStructBegin(\$fname);
1671 while (1)
1672 {
1673 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1674 if ($ftype == TType::STOP) {
1675 last;
1676 }
1677 SWITCH: for($fid)
1678 {
1679 /^0$/ && do{ if ($ftype == TType::STRUCT) {
1680 $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
1681 $xfer += $self->{success}->read($input);
1682 } else {
1683 $xfer += $input->skip($ftype);
1684 }
1685 last; };
1686 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1687 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
1688 $xfer += $self->{userException}->read($input);
1689 } else {
1690 $xfer += $input->skip($ftype);
1691 }
1692 last; };
1693 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1694 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
1695 $xfer += $self->{systemException}->read($input);
1696 } else {
1697 $xfer += $input->skip($ftype);
1698 }
1699 last; };
1700 $xfer += $input->skip($ftype);
1701 }
1702 $xfer += $input->readFieldEnd();
1703 }
1704 $xfer += $input->readStructEnd();
1705 return $xfer;
1706 }
1707  
1708 sub write {
1709 my ($self, $output) = @_;
1710 my $xfer = 0;
1711 $xfer += $output->writeStructBegin('NoteStore_createNotebook_result');
1712 if (defined $self->{success}) {
1713 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1714 $xfer += $self->{success}->write($output);
1715 $xfer += $output->writeFieldEnd();
1716 }
1717 if (defined $self->{userException}) {
1718 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1719 $xfer += $self->{userException}->write($output);
1720 $xfer += $output->writeFieldEnd();
1721 }
1722 if (defined $self->{systemException}) {
1723 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1724 $xfer += $self->{systemException}->write($output);
1725 $xfer += $output->writeFieldEnd();
1726 }
1727 $xfer += $output->writeFieldStop();
1728 $xfer += $output->writeStructEnd();
1729 return $xfer;
1730 }
1731  
1732 package Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args;
1733 use base qw(Class::Accessor);
1734 Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->mk_accessors( qw( authenticationToken notebook ) );
1735  
1736 sub new {
1737 my $classname = shift;
1738 my $self = {};
1739 my $vals = shift || {};
1740 $self->{authenticationToken} = undef;
1741 $self->{notebook} = undef;
1742 if (UNIVERSAL::isa($vals,'HASH')) {
1743 if (defined $vals->{authenticationToken}) {
1744 $self->{authenticationToken} = $vals->{authenticationToken};
1745 }
1746 if (defined $vals->{notebook}) {
1747 $self->{notebook} = $vals->{notebook};
1748 }
1749 }
1750 return bless ($self, $classname);
1751 }
1752  
1753 sub getName {
1754 return 'NoteStore_updateNotebook_args';
1755 }
1756  
1757 sub read {
1758 my ($self, $input) = @_;
1759 my $xfer = 0;
1760 my $fname;
1761 my $ftype = 0;
1762 my $fid = 0;
1763 $xfer += $input->readStructBegin(\$fname);
1764 while (1)
1765 {
1766 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1767 if ($ftype == TType::STOP) {
1768 last;
1769 }
1770 SWITCH: for($fid)
1771 {
1772 /^1$/ && do{ if ($ftype == TType::STRING) {
1773 $xfer += $input->readString(\$self->{authenticationToken});
1774 } else {
1775 $xfer += $input->skip($ftype);
1776 }
1777 last; };
1778 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1779 $self->{notebook} = Net::Evernote::EDAMTypes::Notebook->new();
1780 $xfer += $self->{notebook}->read($input);
1781 } else {
1782 $xfer += $input->skip($ftype);
1783 }
1784 last; };
1785 $xfer += $input->skip($ftype);
1786 }
1787 $xfer += $input->readFieldEnd();
1788 }
1789 $xfer += $input->readStructEnd();
1790 return $xfer;
1791 }
1792  
1793 sub write {
1794 my ($self, $output) = @_;
1795 my $xfer = 0;
1796 $xfer += $output->writeStructBegin('NoteStore_updateNotebook_args');
1797 if (defined $self->{authenticationToken}) {
1798 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1799 $xfer += $output->writeString($self->{authenticationToken});
1800 $xfer += $output->writeFieldEnd();
1801 }
1802 if (defined $self->{notebook}) {
1803 $xfer += $output->writeFieldBegin('notebook', TType::STRUCT, 2);
1804 $xfer += $self->{notebook}->write($output);
1805 $xfer += $output->writeFieldEnd();
1806 }
1807 $xfer += $output->writeFieldStop();
1808 $xfer += $output->writeStructEnd();
1809 return $xfer;
1810 }
1811  
1812 package Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result;
1813 use base qw(Class::Accessor);
1814 Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->mk_accessors( qw( success ) );
1815  
1816 sub new {
1817 my $classname = shift;
1818 my $self = {};
1819 my $vals = shift || {};
1820 $self->{success} = undef;
1821 $self->{userException} = undef;
1822 $self->{systemException} = undef;
1823 $self->{notFoundException} = undef;
1824 if (UNIVERSAL::isa($vals,'HASH')) {
1825 if (defined $vals->{success}) {
1826 $self->{success} = $vals->{success};
1827 }
1828 if (defined $vals->{userException}) {
1829 $self->{userException} = $vals->{userException};
1830 }
1831 if (defined $vals->{systemException}) {
1832 $self->{systemException} = $vals->{systemException};
1833 }
1834 if (defined $vals->{notFoundException}) {
1835 $self->{notFoundException} = $vals->{notFoundException};
1836 }
1837 }
1838 return bless ($self, $classname);
1839 }
1840  
1841 sub getName {
1842 return 'NoteStore_updateNotebook_result';
1843 }
1844  
1845 sub read {
1846 my ($self, $input) = @_;
1847 my $xfer = 0;
1848 my $fname;
1849 my $ftype = 0;
1850 my $fid = 0;
1851 $xfer += $input->readStructBegin(\$fname);
1852 while (1)
1853 {
1854 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1855 if ($ftype == TType::STOP) {
1856 last;
1857 }
1858 SWITCH: for($fid)
1859 {
1860 /^0$/ && do{ if ($ftype == TType::I32) {
1861 $xfer += $input->readI32(\$self->{success});
1862 } else {
1863 $xfer += $input->skip($ftype);
1864 }
1865 last; };
1866 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1867 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
1868 $xfer += $self->{userException}->read($input);
1869 } else {
1870 $xfer += $input->skip($ftype);
1871 }
1872 last; };
1873 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1874 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
1875 $xfer += $self->{systemException}->read($input);
1876 } else {
1877 $xfer += $input->skip($ftype);
1878 }
1879 last; };
1880 /^3$/ && do{ if ($ftype == TType::STRUCT) {
1881 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
1882 $xfer += $self->{notFoundException}->read($input);
1883 } else {
1884 $xfer += $input->skip($ftype);
1885 }
1886 last; };
1887 $xfer += $input->skip($ftype);
1888 }
1889 $xfer += $input->readFieldEnd();
1890 }
1891 $xfer += $input->readStructEnd();
1892 return $xfer;
1893 }
1894  
1895 sub write {
1896 my ($self, $output) = @_;
1897 my $xfer = 0;
1898 $xfer += $output->writeStructBegin('NoteStore_updateNotebook_result');
1899 if (defined $self->{success}) {
1900 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
1901 $xfer += $output->writeI32($self->{success});
1902 $xfer += $output->writeFieldEnd();
1903 }
1904 if (defined $self->{userException}) {
1905 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
1906 $xfer += $self->{userException}->write($output);
1907 $xfer += $output->writeFieldEnd();
1908 }
1909 if (defined $self->{systemException}) {
1910 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
1911 $xfer += $self->{systemException}->write($output);
1912 $xfer += $output->writeFieldEnd();
1913 }
1914 if (defined $self->{notFoundException}) {
1915 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
1916 $xfer += $self->{notFoundException}->write($output);
1917 $xfer += $output->writeFieldEnd();
1918 }
1919 $xfer += $output->writeFieldStop();
1920 $xfer += $output->writeStructEnd();
1921 return $xfer;
1922 }
1923  
1924 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args;
1925 use base qw(Class::Accessor);
1926 Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->mk_accessors( qw( authenticationToken guid ) );
1927  
1928 sub new {
1929 my $classname = shift;
1930 my $self = {};
1931 my $vals = shift || {};
1932 $self->{authenticationToken} = undef;
1933 $self->{guid} = undef;
1934 if (UNIVERSAL::isa($vals,'HASH')) {
1935 if (defined $vals->{authenticationToken}) {
1936 $self->{authenticationToken} = $vals->{authenticationToken};
1937 }
1938 if (defined $vals->{guid}) {
1939 $self->{guid} = $vals->{guid};
1940 }
1941 }
1942 return bless ($self, $classname);
1943 }
1944  
1945 sub getName {
1946 return 'NoteStore_expungeNotebook_args';
1947 }
1948  
1949 sub read {
1950 my ($self, $input) = @_;
1951 my $xfer = 0;
1952 my $fname;
1953 my $ftype = 0;
1954 my $fid = 0;
1955 $xfer += $input->readStructBegin(\$fname);
1956 while (1)
1957 {
1958 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1959 if ($ftype == TType::STOP) {
1960 last;
1961 }
1962 SWITCH: for($fid)
1963 {
1964 /^1$/ && do{ if ($ftype == TType::STRING) {
1965 $xfer += $input->readString(\$self->{authenticationToken});
1966 } else {
1967 $xfer += $input->skip($ftype);
1968 }
1969 last; };
1970 /^2$/ && do{ if ($ftype == TType::STRING) {
1971 $xfer += $input->readString(\$self->{guid});
1972 } else {
1973 $xfer += $input->skip($ftype);
1974 }
1975 last; };
1976 $xfer += $input->skip($ftype);
1977 }
1978 $xfer += $input->readFieldEnd();
1979 }
1980 $xfer += $input->readStructEnd();
1981 return $xfer;
1982 }
1983  
1984 sub write {
1985 my ($self, $output) = @_;
1986 my $xfer = 0;
1987 $xfer += $output->writeStructBegin('NoteStore_expungeNotebook_args');
1988 if (defined $self->{authenticationToken}) {
1989 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
1990 $xfer += $output->writeString($self->{authenticationToken});
1991 $xfer += $output->writeFieldEnd();
1992 }
1993 if (defined $self->{guid}) {
1994 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
1995 $xfer += $output->writeString($self->{guid});
1996 $xfer += $output->writeFieldEnd();
1997 }
1998 $xfer += $output->writeFieldStop();
1999 $xfer += $output->writeStructEnd();
2000 return $xfer;
2001 }
2002  
2003 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result;
2004 use base qw(Class::Accessor);
2005 Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->mk_accessors( qw( success ) );
2006  
2007 sub new {
2008 my $classname = shift;
2009 my $self = {};
2010 my $vals = shift || {};
2011 $self->{success} = undef;
2012 $self->{userException} = undef;
2013 $self->{systemException} = undef;
2014 $self->{notFoundException} = undef;
2015 if (UNIVERSAL::isa($vals,'HASH')) {
2016 if (defined $vals->{success}) {
2017 $self->{success} = $vals->{success};
2018 }
2019 if (defined $vals->{userException}) {
2020 $self->{userException} = $vals->{userException};
2021 }
2022 if (defined $vals->{systemException}) {
2023 $self->{systemException} = $vals->{systemException};
2024 }
2025 if (defined $vals->{notFoundException}) {
2026 $self->{notFoundException} = $vals->{notFoundException};
2027 }
2028 }
2029 return bless ($self, $classname);
2030 }
2031  
2032 sub getName {
2033 return 'NoteStore_expungeNotebook_result';
2034 }
2035  
2036 sub read {
2037 my ($self, $input) = @_;
2038 my $xfer = 0;
2039 my $fname;
2040 my $ftype = 0;
2041 my $fid = 0;
2042 $xfer += $input->readStructBegin(\$fname);
2043 while (1)
2044 {
2045 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2046 if ($ftype == TType::STOP) {
2047 last;
2048 }
2049 SWITCH: for($fid)
2050 {
2051 /^0$/ && do{ if ($ftype == TType::I32) {
2052 $xfer += $input->readI32(\$self->{success});
2053 } else {
2054 $xfer += $input->skip($ftype);
2055 }
2056 last; };
2057 /^1$/ && do{ if ($ftype == TType::STRUCT) {
2058 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
2059 $xfer += $self->{userException}->read($input);
2060 } else {
2061 $xfer += $input->skip($ftype);
2062 }
2063 last; };
2064 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2065 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
2066 $xfer += $self->{systemException}->read($input);
2067 } else {
2068 $xfer += $input->skip($ftype);
2069 }
2070 last; };
2071 /^3$/ && do{ if ($ftype == TType::STRUCT) {
2072 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
2073 $xfer += $self->{notFoundException}->read($input);
2074 } else {
2075 $xfer += $input->skip($ftype);
2076 }
2077 last; };
2078 $xfer += $input->skip($ftype);
2079 }
2080 $xfer += $input->readFieldEnd();
2081 }
2082 $xfer += $input->readStructEnd();
2083 return $xfer;
2084 }
2085  
2086 sub write {
2087 my ($self, $output) = @_;
2088 my $xfer = 0;
2089 $xfer += $output->writeStructBegin('NoteStore_expungeNotebook_result');
2090 if (defined $self->{success}) {
2091 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
2092 $xfer += $output->writeI32($self->{success});
2093 $xfer += $output->writeFieldEnd();
2094 }
2095 if (defined $self->{userException}) {
2096 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
2097 $xfer += $self->{userException}->write($output);
2098 $xfer += $output->writeFieldEnd();
2099 }
2100 if (defined $self->{systemException}) {
2101 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
2102 $xfer += $self->{systemException}->write($output);
2103 $xfer += $output->writeFieldEnd();
2104 }
2105 if (defined $self->{notFoundException}) {
2106 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
2107 $xfer += $self->{notFoundException}->write($output);
2108 $xfer += $output->writeFieldEnd();
2109 }
2110 $xfer += $output->writeFieldStop();
2111 $xfer += $output->writeStructEnd();
2112 return $xfer;
2113 }
2114  
2115 package Net::Evernote::EDAMNoteStore::NoteStore_listTags_args;
2116 use base qw(Class::Accessor);
2117 Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->mk_accessors( qw( authenticationToken ) );
2118  
2119 sub new {
2120 my $classname = shift;
2121 my $self = {};
2122 my $vals = shift || {};
2123 $self->{authenticationToken} = undef;
2124 if (UNIVERSAL::isa($vals,'HASH')) {
2125 if (defined $vals->{authenticationToken}) {
2126 $self->{authenticationToken} = $vals->{authenticationToken};
2127 }
2128 }
2129 return bless ($self, $classname);
2130 }
2131  
2132 sub getName {
2133 return 'NoteStore_listTags_args';
2134 }
2135  
2136 sub read {
2137 my ($self, $input) = @_;
2138 my $xfer = 0;
2139 my $fname;
2140 my $ftype = 0;
2141 my $fid = 0;
2142 $xfer += $input->readStructBegin(\$fname);
2143 while (1)
2144 {
2145 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2146 if ($ftype == TType::STOP) {
2147 last;
2148 }
2149 SWITCH: for($fid)
2150 {
2151 /^1$/ && do{ if ($ftype == TType::STRING) {
2152 $xfer += $input->readString(\$self->{authenticationToken});
2153 } else {
2154 $xfer += $input->skip($ftype);
2155 }
2156 last; };
2157 $xfer += $input->skip($ftype);
2158 }
2159 $xfer += $input->readFieldEnd();
2160 }
2161 $xfer += $input->readStructEnd();
2162 return $xfer;
2163 }
2164  
2165 sub write {
2166 my ($self, $output) = @_;
2167 my $xfer = 0;
2168 $xfer += $output->writeStructBegin('NoteStore_listTags_args');
2169 if (defined $self->{authenticationToken}) {
2170 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
2171 $xfer += $output->writeString($self->{authenticationToken});
2172 $xfer += $output->writeFieldEnd();
2173 }
2174 $xfer += $output->writeFieldStop();
2175 $xfer += $output->writeStructEnd();
2176 return $xfer;
2177 }
2178  
2179 package Net::Evernote::EDAMNoteStore::NoteStore_listTags_result;
2180 use base qw(Class::Accessor);
2181 Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->mk_accessors( qw( success ) );
2182  
2183 sub new {
2184 my $classname = shift;
2185 my $self = {};
2186 my $vals = shift || {};
2187 $self->{success} = undef;
2188 $self->{userException} = undef;
2189 $self->{systemException} = undef;
2190 if (UNIVERSAL::isa($vals,'HASH')) {
2191 if (defined $vals->{success}) {
2192 $self->{success} = $vals->{success};
2193 }
2194 if (defined $vals->{userException}) {
2195 $self->{userException} = $vals->{userException};
2196 }
2197 if (defined $vals->{systemException}) {
2198 $self->{systemException} = $vals->{systemException};
2199 }
2200 }
2201 return bless ($self, $classname);
2202 }
2203  
2204 sub getName {
2205 return 'NoteStore_listTags_result';
2206 }
2207  
2208 sub read {
2209 my ($self, $input) = @_;
2210 my $xfer = 0;
2211 my $fname;
2212 my $ftype = 0;
2213 my $fid = 0;
2214 $xfer += $input->readStructBegin(\$fname);
2215 while (1)
2216 {
2217 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2218 if ($ftype == TType::STOP) {
2219 last;
2220 }
2221 SWITCH: for($fid)
2222 {
2223 /^0$/ && do{ if ($ftype == TType::LIST) {
2224 {
2225 my $_size188 = 0;
2226 $self->{success} = [];
2227 my $_etype191 = 0;
2228 $xfer += $input->readListBegin(\$_etype191, \$_size188);
2229 for (my $_i192 = 0; $_i192 < $_size188; ++$_i192)
2230 {
2231 my $elem193 = undef;
2232 $elem193 = Net::Evernote::EDAMTypes::Tag->new();
2233 $xfer += $elem193->read($input);
2234 push(@{$self->{success}},$elem193);
2235 }
2236 $xfer += $input->readListEnd();
2237 }
2238 } else {
2239 $xfer += $input->skip($ftype);
2240 }
2241 last; };
2242 /^1$/ && do{ if ($ftype == TType::STRUCT) {
2243 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
2244 $xfer += $self->{userException}->read($input);
2245 } else {
2246 $xfer += $input->skip($ftype);
2247 }
2248 last; };
2249 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2250 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
2251 $xfer += $self->{systemException}->read($input);
2252 } else {
2253 $xfer += $input->skip($ftype);
2254 }
2255 last; };
2256 $xfer += $input->skip($ftype);
2257 }
2258 $xfer += $input->readFieldEnd();
2259 }
2260 $xfer += $input->readStructEnd();
2261 return $xfer;
2262 }
2263  
2264 sub write {
2265 my ($self, $output) = @_;
2266 my $xfer = 0;
2267 $xfer += $output->writeStructBegin('NoteStore_listTags_result');
2268 if (defined $self->{success}) {
2269 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
2270 {
2271 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
2272 {
2273 foreach my $iter194 (@{$self->{success}})
2274 {
2275 $xfer += ${iter194}->write($output);
2276 }
2277 }
2278 $xfer += $output->writeListEnd();
2279 }
2280 $xfer += $output->writeFieldEnd();
2281 }
2282 if (defined $self->{userException}) {
2283 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
2284 $xfer += $self->{userException}->write($output);
2285 $xfer += $output->writeFieldEnd();
2286 }
2287 if (defined $self->{systemException}) {
2288 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
2289 $xfer += $self->{systemException}->write($output);
2290 $xfer += $output->writeFieldEnd();
2291 }
2292 $xfer += $output->writeFieldStop();
2293 $xfer += $output->writeStructEnd();
2294 return $xfer;
2295 }
2296  
2297 package Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args;
2298 use base qw(Class::Accessor);
2299 Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->mk_accessors( qw( authenticationToken notebookGuid ) );
2300  
2301 sub new {
2302 my $classname = shift;
2303 my $self = {};
2304 my $vals = shift || {};
2305 $self->{authenticationToken} = undef;
2306 $self->{notebookGuid} = undef;
2307 if (UNIVERSAL::isa($vals,'HASH')) {
2308 if (defined $vals->{authenticationToken}) {
2309 $self->{authenticationToken} = $vals->{authenticationToken};
2310 }
2311 if (defined $vals->{notebookGuid}) {
2312 $self->{notebookGuid} = $vals->{notebookGuid};
2313 }
2314 }
2315 return bless ($self, $classname);
2316 }
2317  
2318 sub getName {
2319 return 'NoteStore_listTagsByNotebook_args';
2320 }
2321  
2322 sub read {
2323 my ($self, $input) = @_;
2324 my $xfer = 0;
2325 my $fname;
2326 my $ftype = 0;
2327 my $fid = 0;
2328 $xfer += $input->readStructBegin(\$fname);
2329 while (1)
2330 {
2331 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2332 if ($ftype == TType::STOP) {
2333 last;
2334 }
2335 SWITCH: for($fid)
2336 {
2337 /^1$/ && do{ if ($ftype == TType::STRING) {
2338 $xfer += $input->readString(\$self->{authenticationToken});
2339 } else {
2340 $xfer += $input->skip($ftype);
2341 }
2342 last; };
2343 /^2$/ && do{ if ($ftype == TType::STRING) {
2344 $xfer += $input->readString(\$self->{notebookGuid});
2345 } else {
2346 $xfer += $input->skip($ftype);
2347 }
2348 last; };
2349 $xfer += $input->skip($ftype);
2350 }
2351 $xfer += $input->readFieldEnd();
2352 }
2353 $xfer += $input->readStructEnd();
2354 return $xfer;
2355 }
2356  
2357 sub write {
2358 my ($self, $output) = @_;
2359 my $xfer = 0;
2360 $xfer += $output->writeStructBegin('NoteStore_listTagsByNotebook_args');
2361 if (defined $self->{authenticationToken}) {
2362 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
2363 $xfer += $output->writeString($self->{authenticationToken});
2364 $xfer += $output->writeFieldEnd();
2365 }
2366 if (defined $self->{notebookGuid}) {
2367 $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 2);
2368 $xfer += $output->writeString($self->{notebookGuid});
2369 $xfer += $output->writeFieldEnd();
2370 }
2371 $xfer += $output->writeFieldStop();
2372 $xfer += $output->writeStructEnd();
2373 return $xfer;
2374 }
2375  
2376 package Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result;
2377 use base qw(Class::Accessor);
2378 Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->mk_accessors( qw( success ) );
2379  
2380 sub new {
2381 my $classname = shift;
2382 my $self = {};
2383 my $vals = shift || {};
2384 $self->{success} = undef;
2385 $self->{userException} = undef;
2386 $self->{systemException} = undef;
2387 $self->{notFoundException} = undef;
2388 if (UNIVERSAL::isa($vals,'HASH')) {
2389 if (defined $vals->{success}) {
2390 $self->{success} = $vals->{success};
2391 }
2392 if (defined $vals->{userException}) {
2393 $self->{userException} = $vals->{userException};
2394 }
2395 if (defined $vals->{systemException}) {
2396 $self->{systemException} = $vals->{systemException};
2397 }
2398 if (defined $vals->{notFoundException}) {
2399 $self->{notFoundException} = $vals->{notFoundException};
2400 }
2401 }
2402 return bless ($self, $classname);
2403 }
2404  
2405 sub getName {
2406 return 'NoteStore_listTagsByNotebook_result';
2407 }
2408  
2409 sub read {
2410 my ($self, $input) = @_;
2411 my $xfer = 0;
2412 my $fname;
2413 my $ftype = 0;
2414 my $fid = 0;
2415 $xfer += $input->readStructBegin(\$fname);
2416 while (1)
2417 {
2418 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2419 if ($ftype == TType::STOP) {
2420 last;
2421 }
2422 SWITCH: for($fid)
2423 {
2424 /^0$/ && do{ if ($ftype == TType::LIST) {
2425 {
2426 my $_size195 = 0;
2427 $self->{success} = [];
2428 my $_etype198 = 0;
2429 $xfer += $input->readListBegin(\$_etype198, \$_size195);
2430 for (my $_i199 = 0; $_i199 < $_size195; ++$_i199)
2431 {
2432 my $elem200 = undef;
2433 $elem200 = Net::Evernote::EDAMTypes::Tag->new();
2434 $xfer += $elem200->read($input);
2435 push(@{$self->{success}},$elem200);
2436 }
2437 $xfer += $input->readListEnd();
2438 }
2439 } else {
2440 $xfer += $input->skip($ftype);
2441 }
2442 last; };
2443 /^1$/ && do{ if ($ftype == TType::STRUCT) {
2444 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
2445 $xfer += $self->{userException}->read($input);
2446 } else {
2447 $xfer += $input->skip($ftype);
2448 }
2449 last; };
2450 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2451 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
2452 $xfer += $self->{systemException}->read($input);
2453 } else {
2454 $xfer += $input->skip($ftype);
2455 }
2456 last; };
2457 /^3$/ && do{ if ($ftype == TType::STRUCT) {
2458 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
2459 $xfer += $self->{notFoundException}->read($input);
2460 } else {
2461 $xfer += $input->skip($ftype);
2462 }
2463 last; };
2464 $xfer += $input->skip($ftype);
2465 }
2466 $xfer += $input->readFieldEnd();
2467 }
2468 $xfer += $input->readStructEnd();
2469 return $xfer;
2470 }
2471  
2472 sub write {
2473 my ($self, $output) = @_;
2474 my $xfer = 0;
2475 $xfer += $output->writeStructBegin('NoteStore_listTagsByNotebook_result');
2476 if (defined $self->{success}) {
2477 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
2478 {
2479 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
2480 {
2481 foreach my $iter201 (@{$self->{success}})
2482 {
2483 $xfer += ${iter201}->write($output);
2484 }
2485 }
2486 $xfer += $output->writeListEnd();
2487 }
2488 $xfer += $output->writeFieldEnd();
2489 }
2490 if (defined $self->{userException}) {
2491 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
2492 $xfer += $self->{userException}->write($output);
2493 $xfer += $output->writeFieldEnd();
2494 }
2495 if (defined $self->{systemException}) {
2496 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
2497 $xfer += $self->{systemException}->write($output);
2498 $xfer += $output->writeFieldEnd();
2499 }
2500 if (defined $self->{notFoundException}) {
2501 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
2502 $xfer += $self->{notFoundException}->write($output);
2503 $xfer += $output->writeFieldEnd();
2504 }
2505 $xfer += $output->writeFieldStop();
2506 $xfer += $output->writeStructEnd();
2507 return $xfer;
2508 }
2509  
2510 package Net::Evernote::EDAMNoteStore::NoteStore_getTag_args;
2511 use base qw(Class::Accessor);
2512 Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->mk_accessors( qw( authenticationToken guid ) );
2513  
2514 sub new {
2515 my $classname = shift;
2516 my $self = {};
2517 my $vals = shift || {};
2518 $self->{authenticationToken} = undef;
2519 $self->{guid} = undef;
2520 if (UNIVERSAL::isa($vals,'HASH')) {
2521 if (defined $vals->{authenticationToken}) {
2522 $self->{authenticationToken} = $vals->{authenticationToken};
2523 }
2524 if (defined $vals->{guid}) {
2525 $self->{guid} = $vals->{guid};
2526 }
2527 }
2528 return bless ($self, $classname);
2529 }
2530  
2531 sub getName {
2532 return 'NoteStore_getTag_args';
2533 }
2534  
2535 sub read {
2536 my ($self, $input) = @_;
2537 my $xfer = 0;
2538 my $fname;
2539 my $ftype = 0;
2540 my $fid = 0;
2541 $xfer += $input->readStructBegin(\$fname);
2542 while (1)
2543 {
2544 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2545 if ($ftype == TType::STOP) {
2546 last;
2547 }
2548 SWITCH: for($fid)
2549 {
2550 /^1$/ && do{ if ($ftype == TType::STRING) {
2551 $xfer += $input->readString(\$self->{authenticationToken});
2552 } else {
2553 $xfer += $input->skip($ftype);
2554 }
2555 last; };
2556 /^2$/ && do{ if ($ftype == TType::STRING) {
2557 $xfer += $input->readString(\$self->{guid});
2558 } else {
2559 $xfer += $input->skip($ftype);
2560 }
2561 last; };
2562 $xfer += $input->skip($ftype);
2563 }
2564 $xfer += $input->readFieldEnd();
2565 }
2566 $xfer += $input->readStructEnd();
2567 return $xfer;
2568 }
2569  
2570 sub write {
2571 my ($self, $output) = @_;
2572 my $xfer = 0;
2573 $xfer += $output->writeStructBegin('NoteStore_getTag_args');
2574 if (defined $self->{authenticationToken}) {
2575 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
2576 $xfer += $output->writeString($self->{authenticationToken});
2577 $xfer += $output->writeFieldEnd();
2578 }
2579 if (defined $self->{guid}) {
2580 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
2581 $xfer += $output->writeString($self->{guid});
2582 $xfer += $output->writeFieldEnd();
2583 }
2584 $xfer += $output->writeFieldStop();
2585 $xfer += $output->writeStructEnd();
2586 return $xfer;
2587 }
2588  
2589 package Net::Evernote::EDAMNoteStore::NoteStore_getTag_result;
2590 use base qw(Class::Accessor);
2591 Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->mk_accessors( qw( success ) );
2592  
2593 sub new {
2594 my $classname = shift;
2595 my $self = {};
2596 my $vals = shift || {};
2597 $self->{success} = undef;
2598 $self->{userException} = undef;
2599 $self->{systemException} = undef;
2600 $self->{notFoundException} = undef;
2601 if (UNIVERSAL::isa($vals,'HASH')) {
2602 if (defined $vals->{success}) {
2603 $self->{success} = $vals->{success};
2604 }
2605 if (defined $vals->{userException}) {
2606 $self->{userException} = $vals->{userException};
2607 }
2608 if (defined $vals->{systemException}) {
2609 $self->{systemException} = $vals->{systemException};
2610 }
2611 if (defined $vals->{notFoundException}) {
2612 $self->{notFoundException} = $vals->{notFoundException};
2613 }
2614 }
2615 return bless ($self, $classname);
2616 }
2617  
2618 sub getName {
2619 return 'NoteStore_getTag_result';
2620 }
2621  
2622 sub read {
2623 my ($self, $input) = @_;
2624 my $xfer = 0;
2625 my $fname;
2626 my $ftype = 0;
2627 my $fid = 0;
2628 $xfer += $input->readStructBegin(\$fname);
2629 while (1)
2630 {
2631 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2632 if ($ftype == TType::STOP) {
2633 last;
2634 }
2635 SWITCH: for($fid)
2636 {
2637 /^0$/ && do{ if ($ftype == TType::STRUCT) {
2638 $self->{success} = Net::Evernote::EDAMTypes::Tag->new();
2639 $xfer += $self->{success}->read($input);
2640 } else {
2641 $xfer += $input->skip($ftype);
2642 }
2643 last; };
2644 /^1$/ && do{ if ($ftype == TType::STRUCT) {
2645 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
2646 $xfer += $self->{userException}->read($input);
2647 } else {
2648 $xfer += $input->skip($ftype);
2649 }
2650 last; };
2651 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2652 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
2653 $xfer += $self->{systemException}->read($input);
2654 } else {
2655 $xfer += $input->skip($ftype);
2656 }
2657 last; };
2658 /^3$/ && do{ if ($ftype == TType::STRUCT) {
2659 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
2660 $xfer += $self->{notFoundException}->read($input);
2661 } else {
2662 $xfer += $input->skip($ftype);
2663 }
2664 last; };
2665 $xfer += $input->skip($ftype);
2666 }
2667 $xfer += $input->readFieldEnd();
2668 }
2669 $xfer += $input->readStructEnd();
2670 return $xfer;
2671 }
2672  
2673 sub write {
2674 my ($self, $output) = @_;
2675 my $xfer = 0;
2676 $xfer += $output->writeStructBegin('NoteStore_getTag_result');
2677 if (defined $self->{success}) {
2678 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2679 $xfer += $self->{success}->write($output);
2680 $xfer += $output->writeFieldEnd();
2681 }
2682 if (defined $self->{userException}) {
2683 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
2684 $xfer += $self->{userException}->write($output);
2685 $xfer += $output->writeFieldEnd();
2686 }
2687 if (defined $self->{systemException}) {
2688 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
2689 $xfer += $self->{systemException}->write($output);
2690 $xfer += $output->writeFieldEnd();
2691 }
2692 if (defined $self->{notFoundException}) {
2693 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
2694 $xfer += $self->{notFoundException}->write($output);
2695 $xfer += $output->writeFieldEnd();
2696 }
2697 $xfer += $output->writeFieldStop();
2698 $xfer += $output->writeStructEnd();
2699 return $xfer;
2700 }
2701  
2702 package Net::Evernote::EDAMNoteStore::NoteStore_createTag_args;
2703 use base qw(Class::Accessor);
2704 Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->mk_accessors( qw( authenticationToken tag ) );
2705  
2706 sub new {
2707 my $classname = shift;
2708 my $self = {};
2709 my $vals = shift || {};
2710 $self->{authenticationToken} = undef;
2711 $self->{tag} = undef;
2712 if (UNIVERSAL::isa($vals,'HASH')) {
2713 if (defined $vals->{authenticationToken}) {
2714 $self->{authenticationToken} = $vals->{authenticationToken};
2715 }
2716 if (defined $vals->{tag}) {
2717 $self->{tag} = $vals->{tag};
2718 }
2719 }
2720 return bless ($self, $classname);
2721 }
2722  
2723 sub getName {
2724 return 'NoteStore_createTag_args';
2725 }
2726  
2727 sub read {
2728 my ($self, $input) = @_;
2729 my $xfer = 0;
2730 my $fname;
2731 my $ftype = 0;
2732 my $fid = 0;
2733 $xfer += $input->readStructBegin(\$fname);
2734 while (1)
2735 {
2736 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2737 if ($ftype == TType::STOP) {
2738 last;
2739 }
2740 SWITCH: for($fid)
2741 {
2742 /^1$/ && do{ if ($ftype == TType::STRING) {
2743 $xfer += $input->readString(\$self->{authenticationToken});
2744 } else {
2745 $xfer += $input->skip($ftype);
2746 }
2747 last; };
2748 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2749 $self->{tag} = Net::Evernote::EDAMTypes::Tag->new();
2750 $xfer += $self->{tag}->read($input);
2751 } else {
2752 $xfer += $input->skip($ftype);
2753 }
2754 last; };
2755 $xfer += $input->skip($ftype);
2756 }
2757 $xfer += $input->readFieldEnd();
2758 }
2759 $xfer += $input->readStructEnd();
2760 return $xfer;
2761 }
2762  
2763 sub write {
2764 my ($self, $output) = @_;
2765 my $xfer = 0;
2766 $xfer += $output->writeStructBegin('NoteStore_createTag_args');
2767 if (defined $self->{authenticationToken}) {
2768 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
2769 $xfer += $output->writeString($self->{authenticationToken});
2770 $xfer += $output->writeFieldEnd();
2771 }
2772 if (defined $self->{tag}) {
2773 $xfer += $output->writeFieldBegin('tag', TType::STRUCT, 2);
2774 $xfer += $self->{tag}->write($output);
2775 $xfer += $output->writeFieldEnd();
2776 }
2777 $xfer += $output->writeFieldStop();
2778 $xfer += $output->writeStructEnd();
2779 return $xfer;
2780 }
2781  
2782 package Net::Evernote::EDAMNoteStore::NoteStore_createTag_result;
2783 use base qw(Class::Accessor);
2784 Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->mk_accessors( qw( success ) );
2785  
2786 sub new {
2787 my $classname = shift;
2788 my $self = {};
2789 my $vals = shift || {};
2790 $self->{success} = undef;
2791 $self->{userException} = undef;
2792 $self->{systemException} = undef;
2793 $self->{notFoundException} = undef;
2794 if (UNIVERSAL::isa($vals,'HASH')) {
2795 if (defined $vals->{success}) {
2796 $self->{success} = $vals->{success};
2797 }
2798 if (defined $vals->{userException}) {
2799 $self->{userException} = $vals->{userException};
2800 }
2801 if (defined $vals->{systemException}) {
2802 $self->{systemException} = $vals->{systemException};
2803 }
2804 if (defined $vals->{notFoundException}) {
2805 $self->{notFoundException} = $vals->{notFoundException};
2806 }
2807 }
2808 return bless ($self, $classname);
2809 }
2810  
2811 sub getName {
2812 return 'NoteStore_createTag_result';
2813 }
2814  
2815 sub read {
2816 my ($self, $input) = @_;
2817 my $xfer = 0;
2818 my $fname;
2819 my $ftype = 0;
2820 my $fid = 0;
2821 $xfer += $input->readStructBegin(\$fname);
2822 while (1)
2823 {
2824 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2825 if ($ftype == TType::STOP) {
2826 last;
2827 }
2828 SWITCH: for($fid)
2829 {
2830 /^0$/ && do{ if ($ftype == TType::STRUCT) {
2831 $self->{success} = Net::Evernote::EDAMTypes::Tag->new();
2832 $xfer += $self->{success}->read($input);
2833 } else {
2834 $xfer += $input->skip($ftype);
2835 }
2836 last; };
2837 /^1$/ && do{ if ($ftype == TType::STRUCT) {
2838 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
2839 $xfer += $self->{userException}->read($input);
2840 } else {
2841 $xfer += $input->skip($ftype);
2842 }
2843 last; };
2844 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2845 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
2846 $xfer += $self->{systemException}->read($input);
2847 } else {
2848 $xfer += $input->skip($ftype);
2849 }
2850 last; };
2851 /^3$/ && do{ if ($ftype == TType::STRUCT) {
2852 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
2853 $xfer += $self->{notFoundException}->read($input);
2854 } else {
2855 $xfer += $input->skip($ftype);
2856 }
2857 last; };
2858 $xfer += $input->skip($ftype);
2859 }
2860 $xfer += $input->readFieldEnd();
2861 }
2862 $xfer += $input->readStructEnd();
2863 return $xfer;
2864 }
2865  
2866 sub write {
2867 my ($self, $output) = @_;
2868 my $xfer = 0;
2869 $xfer += $output->writeStructBegin('NoteStore_createTag_result');
2870 if (defined $self->{success}) {
2871 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2872 $xfer += $self->{success}->write($output);
2873 $xfer += $output->writeFieldEnd();
2874 }
2875 if (defined $self->{userException}) {
2876 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
2877 $xfer += $self->{userException}->write($output);
2878 $xfer += $output->writeFieldEnd();
2879 }
2880 if (defined $self->{systemException}) {
2881 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
2882 $xfer += $self->{systemException}->write($output);
2883 $xfer += $output->writeFieldEnd();
2884 }
2885 if (defined $self->{notFoundException}) {
2886 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
2887 $xfer += $self->{notFoundException}->write($output);
2888 $xfer += $output->writeFieldEnd();
2889 }
2890 $xfer += $output->writeFieldStop();
2891 $xfer += $output->writeStructEnd();
2892 return $xfer;
2893 }
2894  
2895 package Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args;
2896 use base qw(Class::Accessor);
2897 Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->mk_accessors( qw( authenticationToken tag ) );
2898  
2899 sub new {
2900 my $classname = shift;
2901 my $self = {};
2902 my $vals = shift || {};
2903 $self->{authenticationToken} = undef;
2904 $self->{tag} = undef;
2905 if (UNIVERSAL::isa($vals,'HASH')) {
2906 if (defined $vals->{authenticationToken}) {
2907 $self->{authenticationToken} = $vals->{authenticationToken};
2908 }
2909 if (defined $vals->{tag}) {
2910 $self->{tag} = $vals->{tag};
2911 }
2912 }
2913 return bless ($self, $classname);
2914 }
2915  
2916 sub getName {
2917 return 'NoteStore_updateTag_args';
2918 }
2919  
2920 sub read {
2921 my ($self, $input) = @_;
2922 my $xfer = 0;
2923 my $fname;
2924 my $ftype = 0;
2925 my $fid = 0;
2926 $xfer += $input->readStructBegin(\$fname);
2927 while (1)
2928 {
2929 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2930 if ($ftype == TType::STOP) {
2931 last;
2932 }
2933 SWITCH: for($fid)
2934 {
2935 /^1$/ && do{ if ($ftype == TType::STRING) {
2936 $xfer += $input->readString(\$self->{authenticationToken});
2937 } else {
2938 $xfer += $input->skip($ftype);
2939 }
2940 last; };
2941 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2942 $self->{tag} = Net::Evernote::EDAMTypes::Tag->new();
2943 $xfer += $self->{tag}->read($input);
2944 } else {
2945 $xfer += $input->skip($ftype);
2946 }
2947 last; };
2948 $xfer += $input->skip($ftype);
2949 }
2950 $xfer += $input->readFieldEnd();
2951 }
2952 $xfer += $input->readStructEnd();
2953 return $xfer;
2954 }
2955  
2956 sub write {
2957 my ($self, $output) = @_;
2958 my $xfer = 0;
2959 $xfer += $output->writeStructBegin('NoteStore_updateTag_args');
2960 if (defined $self->{authenticationToken}) {
2961 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
2962 $xfer += $output->writeString($self->{authenticationToken});
2963 $xfer += $output->writeFieldEnd();
2964 }
2965 if (defined $self->{tag}) {
2966 $xfer += $output->writeFieldBegin('tag', TType::STRUCT, 2);
2967 $xfer += $self->{tag}->write($output);
2968 $xfer += $output->writeFieldEnd();
2969 }
2970 $xfer += $output->writeFieldStop();
2971 $xfer += $output->writeStructEnd();
2972 return $xfer;
2973 }
2974  
2975 package Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result;
2976 use base qw(Class::Accessor);
2977 Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->mk_accessors( qw( success ) );
2978  
2979 sub new {
2980 my $classname = shift;
2981 my $self = {};
2982 my $vals = shift || {};
2983 $self->{success} = undef;
2984 $self->{userException} = undef;
2985 $self->{systemException} = undef;
2986 $self->{notFoundException} = undef;
2987 if (UNIVERSAL::isa($vals,'HASH')) {
2988 if (defined $vals->{success}) {
2989 $self->{success} = $vals->{success};
2990 }
2991 if (defined $vals->{userException}) {
2992 $self->{userException} = $vals->{userException};
2993 }
2994 if (defined $vals->{systemException}) {
2995 $self->{systemException} = $vals->{systemException};
2996 }
2997 if (defined $vals->{notFoundException}) {
2998 $self->{notFoundException} = $vals->{notFoundException};
2999 }
3000 }
3001 return bless ($self, $classname);
3002 }
3003  
3004 sub getName {
3005 return 'NoteStore_updateTag_result';
3006 }
3007  
3008 sub read {
3009 my ($self, $input) = @_;
3010 my $xfer = 0;
3011 my $fname;
3012 my $ftype = 0;
3013 my $fid = 0;
3014 $xfer += $input->readStructBegin(\$fname);
3015 while (1)
3016 {
3017 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3018 if ($ftype == TType::STOP) {
3019 last;
3020 }
3021 SWITCH: for($fid)
3022 {
3023 /^0$/ && do{ if ($ftype == TType::I32) {
3024 $xfer += $input->readI32(\$self->{success});
3025 } else {
3026 $xfer += $input->skip($ftype);
3027 }
3028 last; };
3029 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3030 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3031 $xfer += $self->{userException}->read($input);
3032 } else {
3033 $xfer += $input->skip($ftype);
3034 }
3035 last; };
3036 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3037 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3038 $xfer += $self->{systemException}->read($input);
3039 } else {
3040 $xfer += $input->skip($ftype);
3041 }
3042 last; };
3043 /^3$/ && do{ if ($ftype == TType::STRUCT) {
3044 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
3045 $xfer += $self->{notFoundException}->read($input);
3046 } else {
3047 $xfer += $input->skip($ftype);
3048 }
3049 last; };
3050 $xfer += $input->skip($ftype);
3051 }
3052 $xfer += $input->readFieldEnd();
3053 }
3054 $xfer += $input->readStructEnd();
3055 return $xfer;
3056 }
3057  
3058 sub write {
3059 my ($self, $output) = @_;
3060 my $xfer = 0;
3061 $xfer += $output->writeStructBegin('NoteStore_updateTag_result');
3062 if (defined $self->{success}) {
3063 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
3064 $xfer += $output->writeI32($self->{success});
3065 $xfer += $output->writeFieldEnd();
3066 }
3067 if (defined $self->{userException}) {
3068 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3069 $xfer += $self->{userException}->write($output);
3070 $xfer += $output->writeFieldEnd();
3071 }
3072 if (defined $self->{systemException}) {
3073 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3074 $xfer += $self->{systemException}->write($output);
3075 $xfer += $output->writeFieldEnd();
3076 }
3077 if (defined $self->{notFoundException}) {
3078 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
3079 $xfer += $self->{notFoundException}->write($output);
3080 $xfer += $output->writeFieldEnd();
3081 }
3082 $xfer += $output->writeFieldStop();
3083 $xfer += $output->writeStructEnd();
3084 return $xfer;
3085 }
3086  
3087 package Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args;
3088 use base qw(Class::Accessor);
3089 Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->mk_accessors( qw( authenticationToken guid ) );
3090  
3091 sub new {
3092 my $classname = shift;
3093 my $self = {};
3094 my $vals = shift || {};
3095 $self->{authenticationToken} = undef;
3096 $self->{guid} = undef;
3097 if (UNIVERSAL::isa($vals,'HASH')) {
3098 if (defined $vals->{authenticationToken}) {
3099 $self->{authenticationToken} = $vals->{authenticationToken};
3100 }
3101 if (defined $vals->{guid}) {
3102 $self->{guid} = $vals->{guid};
3103 }
3104 }
3105 return bless ($self, $classname);
3106 }
3107  
3108 sub getName {
3109 return 'NoteStore_untagAll_args';
3110 }
3111  
3112 sub read {
3113 my ($self, $input) = @_;
3114 my $xfer = 0;
3115 my $fname;
3116 my $ftype = 0;
3117 my $fid = 0;
3118 $xfer += $input->readStructBegin(\$fname);
3119 while (1)
3120 {
3121 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3122 if ($ftype == TType::STOP) {
3123 last;
3124 }
3125 SWITCH: for($fid)
3126 {
3127 /^1$/ && do{ if ($ftype == TType::STRING) {
3128 $xfer += $input->readString(\$self->{authenticationToken});
3129 } else {
3130 $xfer += $input->skip($ftype);
3131 }
3132 last; };
3133 /^2$/ && do{ if ($ftype == TType::STRING) {
3134 $xfer += $input->readString(\$self->{guid});
3135 } else {
3136 $xfer += $input->skip($ftype);
3137 }
3138 last; };
3139 $xfer += $input->skip($ftype);
3140 }
3141 $xfer += $input->readFieldEnd();
3142 }
3143 $xfer += $input->readStructEnd();
3144 return $xfer;
3145 }
3146  
3147 sub write {
3148 my ($self, $output) = @_;
3149 my $xfer = 0;
3150 $xfer += $output->writeStructBegin('NoteStore_untagAll_args');
3151 if (defined $self->{authenticationToken}) {
3152 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
3153 $xfer += $output->writeString($self->{authenticationToken});
3154 $xfer += $output->writeFieldEnd();
3155 }
3156 if (defined $self->{guid}) {
3157 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
3158 $xfer += $output->writeString($self->{guid});
3159 $xfer += $output->writeFieldEnd();
3160 }
3161 $xfer += $output->writeFieldStop();
3162 $xfer += $output->writeStructEnd();
3163 return $xfer;
3164 }
3165  
3166 package Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result;
3167 use base qw(Class::Accessor);
3168 Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->mk_accessors( qw( ) );
3169  
3170 sub new {
3171 my $classname = shift;
3172 my $self = {};
3173 my $vals = shift || {};
3174 $self->{userException} = undef;
3175 $self->{systemException} = undef;
3176 $self->{notFoundException} = undef;
3177 if (UNIVERSAL::isa($vals,'HASH')) {
3178 if (defined $vals->{userException}) {
3179 $self->{userException} = $vals->{userException};
3180 }
3181 if (defined $vals->{systemException}) {
3182 $self->{systemException} = $vals->{systemException};
3183 }
3184 if (defined $vals->{notFoundException}) {
3185 $self->{notFoundException} = $vals->{notFoundException};
3186 }
3187 }
3188 return bless ($self, $classname);
3189 }
3190  
3191 sub getName {
3192 return 'NoteStore_untagAll_result';
3193 }
3194  
3195 sub read {
3196 my ($self, $input) = @_;
3197 my $xfer = 0;
3198 my $fname;
3199 my $ftype = 0;
3200 my $fid = 0;
3201 $xfer += $input->readStructBegin(\$fname);
3202 while (1)
3203 {
3204 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3205 if ($ftype == TType::STOP) {
3206 last;
3207 }
3208 SWITCH: for($fid)
3209 {
3210 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3211 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3212 $xfer += $self->{userException}->read($input);
3213 } else {
3214 $xfer += $input->skip($ftype);
3215 }
3216 last; };
3217 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3218 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3219 $xfer += $self->{systemException}->read($input);
3220 } else {
3221 $xfer += $input->skip($ftype);
3222 }
3223 last; };
3224 /^3$/ && do{ if ($ftype == TType::STRUCT) {
3225 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
3226 $xfer += $self->{notFoundException}->read($input);
3227 } else {
3228 $xfer += $input->skip($ftype);
3229 }
3230 last; };
3231 $xfer += $input->skip($ftype);
3232 }
3233 $xfer += $input->readFieldEnd();
3234 }
3235 $xfer += $input->readStructEnd();
3236 return $xfer;
3237 }
3238  
3239 sub write {
3240 my ($self, $output) = @_;
3241 my $xfer = 0;
3242 $xfer += $output->writeStructBegin('NoteStore_untagAll_result');
3243 if (defined $self->{userException}) {
3244 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3245 $xfer += $self->{userException}->write($output);
3246 $xfer += $output->writeFieldEnd();
3247 }
3248 if (defined $self->{systemException}) {
3249 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3250 $xfer += $self->{systemException}->write($output);
3251 $xfer += $output->writeFieldEnd();
3252 }
3253 if (defined $self->{notFoundException}) {
3254 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
3255 $xfer += $self->{notFoundException}->write($output);
3256 $xfer += $output->writeFieldEnd();
3257 }
3258 $xfer += $output->writeFieldStop();
3259 $xfer += $output->writeStructEnd();
3260 return $xfer;
3261 }
3262  
3263 package Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args;
3264 use base qw(Class::Accessor);
3265 Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->mk_accessors( qw( authenticationToken guid ) );
3266  
3267 sub new {
3268 my $classname = shift;
3269 my $self = {};
3270 my $vals = shift || {};
3271 $self->{authenticationToken} = undef;
3272 $self->{guid} = undef;
3273 if (UNIVERSAL::isa($vals,'HASH')) {
3274 if (defined $vals->{authenticationToken}) {
3275 $self->{authenticationToken} = $vals->{authenticationToken};
3276 }
3277 if (defined $vals->{guid}) {
3278 $self->{guid} = $vals->{guid};
3279 }
3280 }
3281 return bless ($self, $classname);
3282 }
3283  
3284 sub getName {
3285 return 'NoteStore_expungeTag_args';
3286 }
3287  
3288 sub read {
3289 my ($self, $input) = @_;
3290 my $xfer = 0;
3291 my $fname;
3292 my $ftype = 0;
3293 my $fid = 0;
3294 $xfer += $input->readStructBegin(\$fname);
3295 while (1)
3296 {
3297 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3298 if ($ftype == TType::STOP) {
3299 last;
3300 }
3301 SWITCH: for($fid)
3302 {
3303 /^1$/ && do{ if ($ftype == TType::STRING) {
3304 $xfer += $input->readString(\$self->{authenticationToken});
3305 } else {
3306 $xfer += $input->skip($ftype);
3307 }
3308 last; };
3309 /^2$/ && do{ if ($ftype == TType::STRING) {
3310 $xfer += $input->readString(\$self->{guid});
3311 } else {
3312 $xfer += $input->skip($ftype);
3313 }
3314 last; };
3315 $xfer += $input->skip($ftype);
3316 }
3317 $xfer += $input->readFieldEnd();
3318 }
3319 $xfer += $input->readStructEnd();
3320 return $xfer;
3321 }
3322  
3323 sub write {
3324 my ($self, $output) = @_;
3325 my $xfer = 0;
3326 $xfer += $output->writeStructBegin('NoteStore_expungeTag_args');
3327 if (defined $self->{authenticationToken}) {
3328 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
3329 $xfer += $output->writeString($self->{authenticationToken});
3330 $xfer += $output->writeFieldEnd();
3331 }
3332 if (defined $self->{guid}) {
3333 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
3334 $xfer += $output->writeString($self->{guid});
3335 $xfer += $output->writeFieldEnd();
3336 }
3337 $xfer += $output->writeFieldStop();
3338 $xfer += $output->writeStructEnd();
3339 return $xfer;
3340 }
3341  
3342 package Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result;
3343 use base qw(Class::Accessor);
3344 Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->mk_accessors( qw( success ) );
3345  
3346 sub new {
3347 my $classname = shift;
3348 my $self = {};
3349 my $vals = shift || {};
3350 $self->{success} = undef;
3351 $self->{userException} = undef;
3352 $self->{systemException} = undef;
3353 $self->{notFoundException} = undef;
3354 if (UNIVERSAL::isa($vals,'HASH')) {
3355 if (defined $vals->{success}) {
3356 $self->{success} = $vals->{success};
3357 }
3358 if (defined $vals->{userException}) {
3359 $self->{userException} = $vals->{userException};
3360 }
3361 if (defined $vals->{systemException}) {
3362 $self->{systemException} = $vals->{systemException};
3363 }
3364 if (defined $vals->{notFoundException}) {
3365 $self->{notFoundException} = $vals->{notFoundException};
3366 }
3367 }
3368 return bless ($self, $classname);
3369 }
3370  
3371 sub getName {
3372 return 'NoteStore_expungeTag_result';
3373 }
3374  
3375 sub read {
3376 my ($self, $input) = @_;
3377 my $xfer = 0;
3378 my $fname;
3379 my $ftype = 0;
3380 my $fid = 0;
3381 $xfer += $input->readStructBegin(\$fname);
3382 while (1)
3383 {
3384 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3385 if ($ftype == TType::STOP) {
3386 last;
3387 }
3388 SWITCH: for($fid)
3389 {
3390 /^0$/ && do{ if ($ftype == TType::I32) {
3391 $xfer += $input->readI32(\$self->{success});
3392 } else {
3393 $xfer += $input->skip($ftype);
3394 }
3395 last; };
3396 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3397 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3398 $xfer += $self->{userException}->read($input);
3399 } else {
3400 $xfer += $input->skip($ftype);
3401 }
3402 last; };
3403 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3404 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3405 $xfer += $self->{systemException}->read($input);
3406 } else {
3407 $xfer += $input->skip($ftype);
3408 }
3409 last; };
3410 /^3$/ && do{ if ($ftype == TType::STRUCT) {
3411 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
3412 $xfer += $self->{notFoundException}->read($input);
3413 } else {
3414 $xfer += $input->skip($ftype);
3415 }
3416 last; };
3417 $xfer += $input->skip($ftype);
3418 }
3419 $xfer += $input->readFieldEnd();
3420 }
3421 $xfer += $input->readStructEnd();
3422 return $xfer;
3423 }
3424  
3425 sub write {
3426 my ($self, $output) = @_;
3427 my $xfer = 0;
3428 $xfer += $output->writeStructBegin('NoteStore_expungeTag_result');
3429 if (defined $self->{success}) {
3430 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
3431 $xfer += $output->writeI32($self->{success});
3432 $xfer += $output->writeFieldEnd();
3433 }
3434 if (defined $self->{userException}) {
3435 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3436 $xfer += $self->{userException}->write($output);
3437 $xfer += $output->writeFieldEnd();
3438 }
3439 if (defined $self->{systemException}) {
3440 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3441 $xfer += $self->{systemException}->write($output);
3442 $xfer += $output->writeFieldEnd();
3443 }
3444 if (defined $self->{notFoundException}) {
3445 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
3446 $xfer += $self->{notFoundException}->write($output);
3447 $xfer += $output->writeFieldEnd();
3448 }
3449 $xfer += $output->writeFieldStop();
3450 $xfer += $output->writeStructEnd();
3451 return $xfer;
3452 }
3453  
3454 package Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args;
3455 use base qw(Class::Accessor);
3456 Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->mk_accessors( qw( authenticationToken ) );
3457  
3458 sub new {
3459 my $classname = shift;
3460 my $self = {};
3461 my $vals = shift || {};
3462 $self->{authenticationToken} = undef;
3463 if (UNIVERSAL::isa($vals,'HASH')) {
3464 if (defined $vals->{authenticationToken}) {
3465 $self->{authenticationToken} = $vals->{authenticationToken};
3466 }
3467 }
3468 return bless ($self, $classname);
3469 }
3470  
3471 sub getName {
3472 return 'NoteStore_listSearches_args';
3473 }
3474  
3475 sub read {
3476 my ($self, $input) = @_;
3477 my $xfer = 0;
3478 my $fname;
3479 my $ftype = 0;
3480 my $fid = 0;
3481 $xfer += $input->readStructBegin(\$fname);
3482 while (1)
3483 {
3484 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3485 if ($ftype == TType::STOP) {
3486 last;
3487 }
3488 SWITCH: for($fid)
3489 {
3490 /^1$/ && do{ if ($ftype == TType::STRING) {
3491 $xfer += $input->readString(\$self->{authenticationToken});
3492 } else {
3493 $xfer += $input->skip($ftype);
3494 }
3495 last; };
3496 $xfer += $input->skip($ftype);
3497 }
3498 $xfer += $input->readFieldEnd();
3499 }
3500 $xfer += $input->readStructEnd();
3501 return $xfer;
3502 }
3503  
3504 sub write {
3505 my ($self, $output) = @_;
3506 my $xfer = 0;
3507 $xfer += $output->writeStructBegin('NoteStore_listSearches_args');
3508 if (defined $self->{authenticationToken}) {
3509 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
3510 $xfer += $output->writeString($self->{authenticationToken});
3511 $xfer += $output->writeFieldEnd();
3512 }
3513 $xfer += $output->writeFieldStop();
3514 $xfer += $output->writeStructEnd();
3515 return $xfer;
3516 }
3517  
3518 package Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result;
3519 use base qw(Class::Accessor);
3520 Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->mk_accessors( qw( success ) );
3521  
3522 sub new {
3523 my $classname = shift;
3524 my $self = {};
3525 my $vals = shift || {};
3526 $self->{success} = undef;
3527 $self->{userException} = undef;
3528 $self->{systemException} = undef;
3529 if (UNIVERSAL::isa($vals,'HASH')) {
3530 if (defined $vals->{success}) {
3531 $self->{success} = $vals->{success};
3532 }
3533 if (defined $vals->{userException}) {
3534 $self->{userException} = $vals->{userException};
3535 }
3536 if (defined $vals->{systemException}) {
3537 $self->{systemException} = $vals->{systemException};
3538 }
3539 }
3540 return bless ($self, $classname);
3541 }
3542  
3543 sub getName {
3544 return 'NoteStore_listSearches_result';
3545 }
3546  
3547 sub read {
3548 my ($self, $input) = @_;
3549 my $xfer = 0;
3550 my $fname;
3551 my $ftype = 0;
3552 my $fid = 0;
3553 $xfer += $input->readStructBegin(\$fname);
3554 while (1)
3555 {
3556 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3557 if ($ftype == TType::STOP) {
3558 last;
3559 }
3560 SWITCH: for($fid)
3561 {
3562 /^0$/ && do{ if ($ftype == TType::LIST) {
3563 {
3564 my $_size202 = 0;
3565 $self->{success} = [];
3566 my $_etype205 = 0;
3567 $xfer += $input->readListBegin(\$_etype205, \$_size202);
3568 for (my $_i206 = 0; $_i206 < $_size202; ++$_i206)
3569 {
3570 my $elem207 = undef;
3571 $elem207 = Net::Evernote::EDAMTypes::SavedSearch->new();
3572 $xfer += $elem207->read($input);
3573 push(@{$self->{success}},$elem207);
3574 }
3575 $xfer += $input->readListEnd();
3576 }
3577 } else {
3578 $xfer += $input->skip($ftype);
3579 }
3580 last; };
3581 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3582 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3583 $xfer += $self->{userException}->read($input);
3584 } else {
3585 $xfer += $input->skip($ftype);
3586 }
3587 last; };
3588 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3589 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3590 $xfer += $self->{systemException}->read($input);
3591 } else {
3592 $xfer += $input->skip($ftype);
3593 }
3594 last; };
3595 $xfer += $input->skip($ftype);
3596 }
3597 $xfer += $input->readFieldEnd();
3598 }
3599 $xfer += $input->readStructEnd();
3600 return $xfer;
3601 }
3602  
3603 sub write {
3604 my ($self, $output) = @_;
3605 my $xfer = 0;
3606 $xfer += $output->writeStructBegin('NoteStore_listSearches_result');
3607 if (defined $self->{success}) {
3608 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
3609 {
3610 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
3611 {
3612 foreach my $iter208 (@{$self->{success}})
3613 {
3614 $xfer += ${iter208}->write($output);
3615 }
3616 }
3617 $xfer += $output->writeListEnd();
3618 }
3619 $xfer += $output->writeFieldEnd();
3620 }
3621 if (defined $self->{userException}) {
3622 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3623 $xfer += $self->{userException}->write($output);
3624 $xfer += $output->writeFieldEnd();
3625 }
3626 if (defined $self->{systemException}) {
3627 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3628 $xfer += $self->{systemException}->write($output);
3629 $xfer += $output->writeFieldEnd();
3630 }
3631 $xfer += $output->writeFieldStop();
3632 $xfer += $output->writeStructEnd();
3633 return $xfer;
3634 }
3635  
3636 package Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args;
3637 use base qw(Class::Accessor);
3638 Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->mk_accessors( qw( authenticationToken guid ) );
3639  
3640 sub new {
3641 my $classname = shift;
3642 my $self = {};
3643 my $vals = shift || {};
3644 $self->{authenticationToken} = undef;
3645 $self->{guid} = undef;
3646 if (UNIVERSAL::isa($vals,'HASH')) {
3647 if (defined $vals->{authenticationToken}) {
3648 $self->{authenticationToken} = $vals->{authenticationToken};
3649 }
3650 if (defined $vals->{guid}) {
3651 $self->{guid} = $vals->{guid};
3652 }
3653 }
3654 return bless ($self, $classname);
3655 }
3656  
3657 sub getName {
3658 return 'NoteStore_getSearch_args';
3659 }
3660  
3661 sub read {
3662 my ($self, $input) = @_;
3663 my $xfer = 0;
3664 my $fname;
3665 my $ftype = 0;
3666 my $fid = 0;
3667 $xfer += $input->readStructBegin(\$fname);
3668 while (1)
3669 {
3670 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3671 if ($ftype == TType::STOP) {
3672 last;
3673 }
3674 SWITCH: for($fid)
3675 {
3676 /^1$/ && do{ if ($ftype == TType::STRING) {
3677 $xfer += $input->readString(\$self->{authenticationToken});
3678 } else {
3679 $xfer += $input->skip($ftype);
3680 }
3681 last; };
3682 /^2$/ && do{ if ($ftype == TType::STRING) {
3683 $xfer += $input->readString(\$self->{guid});
3684 } else {
3685 $xfer += $input->skip($ftype);
3686 }
3687 last; };
3688 $xfer += $input->skip($ftype);
3689 }
3690 $xfer += $input->readFieldEnd();
3691 }
3692 $xfer += $input->readStructEnd();
3693 return $xfer;
3694 }
3695  
3696 sub write {
3697 my ($self, $output) = @_;
3698 my $xfer = 0;
3699 $xfer += $output->writeStructBegin('NoteStore_getSearch_args');
3700 if (defined $self->{authenticationToken}) {
3701 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
3702 $xfer += $output->writeString($self->{authenticationToken});
3703 $xfer += $output->writeFieldEnd();
3704 }
3705 if (defined $self->{guid}) {
3706 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
3707 $xfer += $output->writeString($self->{guid});
3708 $xfer += $output->writeFieldEnd();
3709 }
3710 $xfer += $output->writeFieldStop();
3711 $xfer += $output->writeStructEnd();
3712 return $xfer;
3713 }
3714  
3715 package Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result;
3716 use base qw(Class::Accessor);
3717 Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->mk_accessors( qw( success ) );
3718  
3719 sub new {
3720 my $classname = shift;
3721 my $self = {};
3722 my $vals = shift || {};
3723 $self->{success} = undef;
3724 $self->{userException} = undef;
3725 $self->{systemException} = undef;
3726 $self->{notFoundException} = undef;
3727 if (UNIVERSAL::isa($vals,'HASH')) {
3728 if (defined $vals->{success}) {
3729 $self->{success} = $vals->{success};
3730 }
3731 if (defined $vals->{userException}) {
3732 $self->{userException} = $vals->{userException};
3733 }
3734 if (defined $vals->{systemException}) {
3735 $self->{systemException} = $vals->{systemException};
3736 }
3737 if (defined $vals->{notFoundException}) {
3738 $self->{notFoundException} = $vals->{notFoundException};
3739 }
3740 }
3741 return bless ($self, $classname);
3742 }
3743  
3744 sub getName {
3745 return 'NoteStore_getSearch_result';
3746 }
3747  
3748 sub read {
3749 my ($self, $input) = @_;
3750 my $xfer = 0;
3751 my $fname;
3752 my $ftype = 0;
3753 my $fid = 0;
3754 $xfer += $input->readStructBegin(\$fname);
3755 while (1)
3756 {
3757 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3758 if ($ftype == TType::STOP) {
3759 last;
3760 }
3761 SWITCH: for($fid)
3762 {
3763 /^0$/ && do{ if ($ftype == TType::STRUCT) {
3764 $self->{success} = Net::Evernote::EDAMTypes::SavedSearch->new();
3765 $xfer += $self->{success}->read($input);
3766 } else {
3767 $xfer += $input->skip($ftype);
3768 }
3769 last; };
3770 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3771 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3772 $xfer += $self->{userException}->read($input);
3773 } else {
3774 $xfer += $input->skip($ftype);
3775 }
3776 last; };
3777 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3778 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3779 $xfer += $self->{systemException}->read($input);
3780 } else {
3781 $xfer += $input->skip($ftype);
3782 }
3783 last; };
3784 /^3$/ && do{ if ($ftype == TType::STRUCT) {
3785 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
3786 $xfer += $self->{notFoundException}->read($input);
3787 } else {
3788 $xfer += $input->skip($ftype);
3789 }
3790 last; };
3791 $xfer += $input->skip($ftype);
3792 }
3793 $xfer += $input->readFieldEnd();
3794 }
3795 $xfer += $input->readStructEnd();
3796 return $xfer;
3797 }
3798  
3799 sub write {
3800 my ($self, $output) = @_;
3801 my $xfer = 0;
3802 $xfer += $output->writeStructBegin('NoteStore_getSearch_result');
3803 if (defined $self->{success}) {
3804 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3805 $xfer += $self->{success}->write($output);
3806 $xfer += $output->writeFieldEnd();
3807 }
3808 if (defined $self->{userException}) {
3809 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3810 $xfer += $self->{userException}->write($output);
3811 $xfer += $output->writeFieldEnd();
3812 }
3813 if (defined $self->{systemException}) {
3814 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3815 $xfer += $self->{systemException}->write($output);
3816 $xfer += $output->writeFieldEnd();
3817 }
3818 if (defined $self->{notFoundException}) {
3819 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
3820 $xfer += $self->{notFoundException}->write($output);
3821 $xfer += $output->writeFieldEnd();
3822 }
3823 $xfer += $output->writeFieldStop();
3824 $xfer += $output->writeStructEnd();
3825 return $xfer;
3826 }
3827  
3828 package Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args;
3829 use base qw(Class::Accessor);
3830 Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->mk_accessors( qw( authenticationToken search ) );
3831  
3832 sub new {
3833 my $classname = shift;
3834 my $self = {};
3835 my $vals = shift || {};
3836 $self->{authenticationToken} = undef;
3837 $self->{search} = undef;
3838 if (UNIVERSAL::isa($vals,'HASH')) {
3839 if (defined $vals->{authenticationToken}) {
3840 $self->{authenticationToken} = $vals->{authenticationToken};
3841 }
3842 if (defined $vals->{search}) {
3843 $self->{search} = $vals->{search};
3844 }
3845 }
3846 return bless ($self, $classname);
3847 }
3848  
3849 sub getName {
3850 return 'NoteStore_createSearch_args';
3851 }
3852  
3853 sub read {
3854 my ($self, $input) = @_;
3855 my $xfer = 0;
3856 my $fname;
3857 my $ftype = 0;
3858 my $fid = 0;
3859 $xfer += $input->readStructBegin(\$fname);
3860 while (1)
3861 {
3862 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3863 if ($ftype == TType::STOP) {
3864 last;
3865 }
3866 SWITCH: for($fid)
3867 {
3868 /^1$/ && do{ if ($ftype == TType::STRING) {
3869 $xfer += $input->readString(\$self->{authenticationToken});
3870 } else {
3871 $xfer += $input->skip($ftype);
3872 }
3873 last; };
3874 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3875 $self->{search} = Net::Evernote::EDAMTypes::SavedSearch->new();
3876 $xfer += $self->{search}->read($input);
3877 } else {
3878 $xfer += $input->skip($ftype);
3879 }
3880 last; };
3881 $xfer += $input->skip($ftype);
3882 }
3883 $xfer += $input->readFieldEnd();
3884 }
3885 $xfer += $input->readStructEnd();
3886 return $xfer;
3887 }
3888  
3889 sub write {
3890 my ($self, $output) = @_;
3891 my $xfer = 0;
3892 $xfer += $output->writeStructBegin('NoteStore_createSearch_args');
3893 if (defined $self->{authenticationToken}) {
3894 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
3895 $xfer += $output->writeString($self->{authenticationToken});
3896 $xfer += $output->writeFieldEnd();
3897 }
3898 if (defined $self->{search}) {
3899 $xfer += $output->writeFieldBegin('search', TType::STRUCT, 2);
3900 $xfer += $self->{search}->write($output);
3901 $xfer += $output->writeFieldEnd();
3902 }
3903 $xfer += $output->writeFieldStop();
3904 $xfer += $output->writeStructEnd();
3905 return $xfer;
3906 }
3907  
3908 package Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result;
3909 use base qw(Class::Accessor);
3910 Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->mk_accessors( qw( success ) );
3911  
3912 sub new {
3913 my $classname = shift;
3914 my $self = {};
3915 my $vals = shift || {};
3916 $self->{success} = undef;
3917 $self->{userException} = undef;
3918 $self->{systemException} = undef;
3919 if (UNIVERSAL::isa($vals,'HASH')) {
3920 if (defined $vals->{success}) {
3921 $self->{success} = $vals->{success};
3922 }
3923 if (defined $vals->{userException}) {
3924 $self->{userException} = $vals->{userException};
3925 }
3926 if (defined $vals->{systemException}) {
3927 $self->{systemException} = $vals->{systemException};
3928 }
3929 }
3930 return bless ($self, $classname);
3931 }
3932  
3933 sub getName {
3934 return 'NoteStore_createSearch_result';
3935 }
3936  
3937 sub read {
3938 my ($self, $input) = @_;
3939 my $xfer = 0;
3940 my $fname;
3941 my $ftype = 0;
3942 my $fid = 0;
3943 $xfer += $input->readStructBegin(\$fname);
3944 while (1)
3945 {
3946 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
3947 if ($ftype == TType::STOP) {
3948 last;
3949 }
3950 SWITCH: for($fid)
3951 {
3952 /^0$/ && do{ if ($ftype == TType::STRUCT) {
3953 $self->{success} = Net::Evernote::EDAMTypes::SavedSearch->new();
3954 $xfer += $self->{success}->read($input);
3955 } else {
3956 $xfer += $input->skip($ftype);
3957 }
3958 last; };
3959 /^1$/ && do{ if ($ftype == TType::STRUCT) {
3960 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
3961 $xfer += $self->{userException}->read($input);
3962 } else {
3963 $xfer += $input->skip($ftype);
3964 }
3965 last; };
3966 /^2$/ && do{ if ($ftype == TType::STRUCT) {
3967 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
3968 $xfer += $self->{systemException}->read($input);
3969 } else {
3970 $xfer += $input->skip($ftype);
3971 }
3972 last; };
3973 $xfer += $input->skip($ftype);
3974 }
3975 $xfer += $input->readFieldEnd();
3976 }
3977 $xfer += $input->readStructEnd();
3978 return $xfer;
3979 }
3980  
3981 sub write {
3982 my ($self, $output) = @_;
3983 my $xfer = 0;
3984 $xfer += $output->writeStructBegin('NoteStore_createSearch_result');
3985 if (defined $self->{success}) {
3986 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3987 $xfer += $self->{success}->write($output);
3988 $xfer += $output->writeFieldEnd();
3989 }
3990 if (defined $self->{userException}) {
3991 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
3992 $xfer += $self->{userException}->write($output);
3993 $xfer += $output->writeFieldEnd();
3994 }
3995 if (defined $self->{systemException}) {
3996 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
3997 $xfer += $self->{systemException}->write($output);
3998 $xfer += $output->writeFieldEnd();
3999 }
4000 $xfer += $output->writeFieldStop();
4001 $xfer += $output->writeStructEnd();
4002 return $xfer;
4003 }
4004  
4005 package Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args;
4006 use base qw(Class::Accessor);
4007 Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->mk_accessors( qw( authenticationToken search ) );
4008  
4009 sub new {
4010 my $classname = shift;
4011 my $self = {};
4012 my $vals = shift || {};
4013 $self->{authenticationToken} = undef;
4014 $self->{search} = undef;
4015 if (UNIVERSAL::isa($vals,'HASH')) {
4016 if (defined $vals->{authenticationToken}) {
4017 $self->{authenticationToken} = $vals->{authenticationToken};
4018 }
4019 if (defined $vals->{search}) {
4020 $self->{search} = $vals->{search};
4021 }
4022 }
4023 return bless ($self, $classname);
4024 }
4025  
4026 sub getName {
4027 return 'NoteStore_updateSearch_args';
4028 }
4029  
4030 sub read {
4031 my ($self, $input) = @_;
4032 my $xfer = 0;
4033 my $fname;
4034 my $ftype = 0;
4035 my $fid = 0;
4036 $xfer += $input->readStructBegin(\$fname);
4037 while (1)
4038 {
4039 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4040 if ($ftype == TType::STOP) {
4041 last;
4042 }
4043 SWITCH: for($fid)
4044 {
4045 /^1$/ && do{ if ($ftype == TType::STRING) {
4046 $xfer += $input->readString(\$self->{authenticationToken});
4047 } else {
4048 $xfer += $input->skip($ftype);
4049 }
4050 last; };
4051 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4052 $self->{search} = Net::Evernote::EDAMTypes::SavedSearch->new();
4053 $xfer += $self->{search}->read($input);
4054 } else {
4055 $xfer += $input->skip($ftype);
4056 }
4057 last; };
4058 $xfer += $input->skip($ftype);
4059 }
4060 $xfer += $input->readFieldEnd();
4061 }
4062 $xfer += $input->readStructEnd();
4063 return $xfer;
4064 }
4065  
4066 sub write {
4067 my ($self, $output) = @_;
4068 my $xfer = 0;
4069 $xfer += $output->writeStructBegin('NoteStore_updateSearch_args');
4070 if (defined $self->{authenticationToken}) {
4071 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
4072 $xfer += $output->writeString($self->{authenticationToken});
4073 $xfer += $output->writeFieldEnd();
4074 }
4075 if (defined $self->{search}) {
4076 $xfer += $output->writeFieldBegin('search', TType::STRUCT, 2);
4077 $xfer += $self->{search}->write($output);
4078 $xfer += $output->writeFieldEnd();
4079 }
4080 $xfer += $output->writeFieldStop();
4081 $xfer += $output->writeStructEnd();
4082 return $xfer;
4083 }
4084  
4085 package Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result;
4086 use base qw(Class::Accessor);
4087 Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->mk_accessors( qw( success ) );
4088  
4089 sub new {
4090 my $classname = shift;
4091 my $self = {};
4092 my $vals = shift || {};
4093 $self->{success} = undef;
4094 $self->{userException} = undef;
4095 $self->{systemException} = undef;
4096 $self->{notFoundException} = undef;
4097 if (UNIVERSAL::isa($vals,'HASH')) {
4098 if (defined $vals->{success}) {
4099 $self->{success} = $vals->{success};
4100 }
4101 if (defined $vals->{userException}) {
4102 $self->{userException} = $vals->{userException};
4103 }
4104 if (defined $vals->{systemException}) {
4105 $self->{systemException} = $vals->{systemException};
4106 }
4107 if (defined $vals->{notFoundException}) {
4108 $self->{notFoundException} = $vals->{notFoundException};
4109 }
4110 }
4111 return bless ($self, $classname);
4112 }
4113  
4114 sub getName {
4115 return 'NoteStore_updateSearch_result';
4116 }
4117  
4118 sub read {
4119 my ($self, $input) = @_;
4120 my $xfer = 0;
4121 my $fname;
4122 my $ftype = 0;
4123 my $fid = 0;
4124 $xfer += $input->readStructBegin(\$fname);
4125 while (1)
4126 {
4127 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4128 if ($ftype == TType::STOP) {
4129 last;
4130 }
4131 SWITCH: for($fid)
4132 {
4133 /^0$/ && do{ if ($ftype == TType::I32) {
4134 $xfer += $input->readI32(\$self->{success});
4135 } else {
4136 $xfer += $input->skip($ftype);
4137 }
4138 last; };
4139 /^1$/ && do{ if ($ftype == TType::STRUCT) {
4140 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
4141 $xfer += $self->{userException}->read($input);
4142 } else {
4143 $xfer += $input->skip($ftype);
4144 }
4145 last; };
4146 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4147 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
4148 $xfer += $self->{systemException}->read($input);
4149 } else {
4150 $xfer += $input->skip($ftype);
4151 }
4152 last; };
4153 /^3$/ && do{ if ($ftype == TType::STRUCT) {
4154 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
4155 $xfer += $self->{notFoundException}->read($input);
4156 } else {
4157 $xfer += $input->skip($ftype);
4158 }
4159 last; };
4160 $xfer += $input->skip($ftype);
4161 }
4162 $xfer += $input->readFieldEnd();
4163 }
4164 $xfer += $input->readStructEnd();
4165 return $xfer;
4166 }
4167  
4168 sub write {
4169 my ($self, $output) = @_;
4170 my $xfer = 0;
4171 $xfer += $output->writeStructBegin('NoteStore_updateSearch_result');
4172 if (defined $self->{success}) {
4173 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
4174 $xfer += $output->writeI32($self->{success});
4175 $xfer += $output->writeFieldEnd();
4176 }
4177 if (defined $self->{userException}) {
4178 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
4179 $xfer += $self->{userException}->write($output);
4180 $xfer += $output->writeFieldEnd();
4181 }
4182 if (defined $self->{systemException}) {
4183 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
4184 $xfer += $self->{systemException}->write($output);
4185 $xfer += $output->writeFieldEnd();
4186 }
4187 if (defined $self->{notFoundException}) {
4188 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
4189 $xfer += $self->{notFoundException}->write($output);
4190 $xfer += $output->writeFieldEnd();
4191 }
4192 $xfer += $output->writeFieldStop();
4193 $xfer += $output->writeStructEnd();
4194 return $xfer;
4195 }
4196  
4197 package Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args;
4198 use base qw(Class::Accessor);
4199 Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->mk_accessors( qw( authenticationToken guid ) );
4200  
4201 sub new {
4202 my $classname = shift;
4203 my $self = {};
4204 my $vals = shift || {};
4205 $self->{authenticationToken} = undef;
4206 $self->{guid} = undef;
4207 if (UNIVERSAL::isa($vals,'HASH')) {
4208 if (defined $vals->{authenticationToken}) {
4209 $self->{authenticationToken} = $vals->{authenticationToken};
4210 }
4211 if (defined $vals->{guid}) {
4212 $self->{guid} = $vals->{guid};
4213 }
4214 }
4215 return bless ($self, $classname);
4216 }
4217  
4218 sub getName {
4219 return 'NoteStore_expungeSearch_args';
4220 }
4221  
4222 sub read {
4223 my ($self, $input) = @_;
4224 my $xfer = 0;
4225 my $fname;
4226 my $ftype = 0;
4227 my $fid = 0;
4228 $xfer += $input->readStructBegin(\$fname);
4229 while (1)
4230 {
4231 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4232 if ($ftype == TType::STOP) {
4233 last;
4234 }
4235 SWITCH: for($fid)
4236 {
4237 /^1$/ && do{ if ($ftype == TType::STRING) {
4238 $xfer += $input->readString(\$self->{authenticationToken});
4239 } else {
4240 $xfer += $input->skip($ftype);
4241 }
4242 last; };
4243 /^2$/ && do{ if ($ftype == TType::STRING) {
4244 $xfer += $input->readString(\$self->{guid});
4245 } else {
4246 $xfer += $input->skip($ftype);
4247 }
4248 last; };
4249 $xfer += $input->skip($ftype);
4250 }
4251 $xfer += $input->readFieldEnd();
4252 }
4253 $xfer += $input->readStructEnd();
4254 return $xfer;
4255 }
4256  
4257 sub write {
4258 my ($self, $output) = @_;
4259 my $xfer = 0;
4260 $xfer += $output->writeStructBegin('NoteStore_expungeSearch_args');
4261 if (defined $self->{authenticationToken}) {
4262 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
4263 $xfer += $output->writeString($self->{authenticationToken});
4264 $xfer += $output->writeFieldEnd();
4265 }
4266 if (defined $self->{guid}) {
4267 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
4268 $xfer += $output->writeString($self->{guid});
4269 $xfer += $output->writeFieldEnd();
4270 }
4271 $xfer += $output->writeFieldStop();
4272 $xfer += $output->writeStructEnd();
4273 return $xfer;
4274 }
4275  
4276 package Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result;
4277 use base qw(Class::Accessor);
4278 Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->mk_accessors( qw( success ) );
4279  
4280 sub new {
4281 my $classname = shift;
4282 my $self = {};
4283 my $vals = shift || {};
4284 $self->{success} = undef;
4285 $self->{userException} = undef;
4286 $self->{systemException} = undef;
4287 $self->{notFoundException} = undef;
4288 if (UNIVERSAL::isa($vals,'HASH')) {
4289 if (defined $vals->{success}) {
4290 $self->{success} = $vals->{success};
4291 }
4292 if (defined $vals->{userException}) {
4293 $self->{userException} = $vals->{userException};
4294 }
4295 if (defined $vals->{systemException}) {
4296 $self->{systemException} = $vals->{systemException};
4297 }
4298 if (defined $vals->{notFoundException}) {
4299 $self->{notFoundException} = $vals->{notFoundException};
4300 }
4301 }
4302 return bless ($self, $classname);
4303 }
4304  
4305 sub getName {
4306 return 'NoteStore_expungeSearch_result';
4307 }
4308  
4309 sub read {
4310 my ($self, $input) = @_;
4311 my $xfer = 0;
4312 my $fname;
4313 my $ftype = 0;
4314 my $fid = 0;
4315 $xfer += $input->readStructBegin(\$fname);
4316 while (1)
4317 {
4318 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4319 if ($ftype == TType::STOP) {
4320 last;
4321 }
4322 SWITCH: for($fid)
4323 {
4324 /^0$/ && do{ if ($ftype == TType::I32) {
4325 $xfer += $input->readI32(\$self->{success});
4326 } else {
4327 $xfer += $input->skip($ftype);
4328 }
4329 last; };
4330 /^1$/ && do{ if ($ftype == TType::STRUCT) {
4331 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
4332 $xfer += $self->{userException}->read($input);
4333 } else {
4334 $xfer += $input->skip($ftype);
4335 }
4336 last; };
4337 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4338 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
4339 $xfer += $self->{systemException}->read($input);
4340 } else {
4341 $xfer += $input->skip($ftype);
4342 }
4343 last; };
4344 /^3$/ && do{ if ($ftype == TType::STRUCT) {
4345 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
4346 $xfer += $self->{notFoundException}->read($input);
4347 } else {
4348 $xfer += $input->skip($ftype);
4349 }
4350 last; };
4351 $xfer += $input->skip($ftype);
4352 }
4353 $xfer += $input->readFieldEnd();
4354 }
4355 $xfer += $input->readStructEnd();
4356 return $xfer;
4357 }
4358  
4359 sub write {
4360 my ($self, $output) = @_;
4361 my $xfer = 0;
4362 $xfer += $output->writeStructBegin('NoteStore_expungeSearch_result');
4363 if (defined $self->{success}) {
4364 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
4365 $xfer += $output->writeI32($self->{success});
4366 $xfer += $output->writeFieldEnd();
4367 }
4368 if (defined $self->{userException}) {
4369 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
4370 $xfer += $self->{userException}->write($output);
4371 $xfer += $output->writeFieldEnd();
4372 }
4373 if (defined $self->{systemException}) {
4374 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
4375 $xfer += $self->{systemException}->write($output);
4376 $xfer += $output->writeFieldEnd();
4377 }
4378 if (defined $self->{notFoundException}) {
4379 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
4380 $xfer += $self->{notFoundException}->write($output);
4381 $xfer += $output->writeFieldEnd();
4382 }
4383 $xfer += $output->writeFieldStop();
4384 $xfer += $output->writeStructEnd();
4385 return $xfer;
4386 }
4387  
4388 package Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args;
4389 use base qw(Class::Accessor);
4390 Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->mk_accessors( qw( authenticationToken filter offset maxNotes ) );
4391  
4392 sub new {
4393 my $classname = shift;
4394 my $self = {};
4395 my $vals = shift || {};
4396 $self->{authenticationToken} = undef;
4397 $self->{filter} = undef;
4398 $self->{offset} = undef;
4399 $self->{maxNotes} = undef;
4400 if (UNIVERSAL::isa($vals,'HASH')) {
4401 if (defined $vals->{authenticationToken}) {
4402 $self->{authenticationToken} = $vals->{authenticationToken};
4403 }
4404 if (defined $vals->{filter}) {
4405 $self->{filter} = $vals->{filter};
4406 }
4407 if (defined $vals->{offset}) {
4408 $self->{offset} = $vals->{offset};
4409 }
4410 if (defined $vals->{maxNotes}) {
4411 $self->{maxNotes} = $vals->{maxNotes};
4412 }
4413 }
4414 return bless ($self, $classname);
4415 }
4416  
4417 sub getName {
4418 return 'NoteStore_findNotes_args';
4419 }
4420  
4421 sub read {
4422 my ($self, $input) = @_;
4423 my $xfer = 0;
4424 my $fname;
4425 my $ftype = 0;
4426 my $fid = 0;
4427 $xfer += $input->readStructBegin(\$fname);
4428 while (1)
4429 {
4430 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4431 if ($ftype == TType::STOP) {
4432 last;
4433 }
4434 SWITCH: for($fid)
4435 {
4436 /^1$/ && do{ if ($ftype == TType::STRING) {
4437 $xfer += $input->readString(\$self->{authenticationToken});
4438 } else {
4439 $xfer += $input->skip($ftype);
4440 }
4441 last; };
4442 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4443 $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
4444 $xfer += $self->{filter}->read($input);
4445 } else {
4446 $xfer += $input->skip($ftype);
4447 }
4448 last; };
4449 /^3$/ && do{ if ($ftype == TType::I32) {
4450 $xfer += $input->readI32(\$self->{offset});
4451 } else {
4452 $xfer += $input->skip($ftype);
4453 }
4454 last; };
4455 /^4$/ && do{ if ($ftype == TType::I32) {
4456 $xfer += $input->readI32(\$self->{maxNotes});
4457 } else {
4458 $xfer += $input->skip($ftype);
4459 }
4460 last; };
4461 $xfer += $input->skip($ftype);
4462 }
4463 $xfer += $input->readFieldEnd();
4464 }
4465 $xfer += $input->readStructEnd();
4466 return $xfer;
4467 }
4468  
4469 sub write {
4470 my ($self, $output) = @_;
4471 my $xfer = 0;
4472 $xfer += $output->writeStructBegin('NoteStore_findNotes_args');
4473 if (defined $self->{authenticationToken}) {
4474 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
4475 $xfer += $output->writeString($self->{authenticationToken});
4476 $xfer += $output->writeFieldEnd();
4477 }
4478 if (defined $self->{filter}) {
4479 $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
4480 $xfer += $self->{filter}->write($output);
4481 $xfer += $output->writeFieldEnd();
4482 }
4483 if (defined $self->{offset}) {
4484 $xfer += $output->writeFieldBegin('offset', TType::I32, 3);
4485 $xfer += $output->writeI32($self->{offset});
4486 $xfer += $output->writeFieldEnd();
4487 }
4488 if (defined $self->{maxNotes}) {
4489 $xfer += $output->writeFieldBegin('maxNotes', TType::I32, 4);
4490 $xfer += $output->writeI32($self->{maxNotes});
4491 $xfer += $output->writeFieldEnd();
4492 }
4493 $xfer += $output->writeFieldStop();
4494 $xfer += $output->writeStructEnd();
4495 return $xfer;
4496 }
4497  
4498 package Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result;
4499 use base qw(Class::Accessor);
4500 Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->mk_accessors( qw( success ) );
4501  
4502 sub new {
4503 my $classname = shift;
4504 my $self = {};
4505 my $vals = shift || {};
4506 $self->{success} = undef;
4507 $self->{userException} = undef;
4508 $self->{systemException} = undef;
4509 $self->{notFoundException} = undef;
4510 if (UNIVERSAL::isa($vals,'HASH')) {
4511 if (defined $vals->{success}) {
4512 $self->{success} = $vals->{success};
4513 }
4514 if (defined $vals->{userException}) {
4515 $self->{userException} = $vals->{userException};
4516 }
4517 if (defined $vals->{systemException}) {
4518 $self->{systemException} = $vals->{systemException};
4519 }
4520 if (defined $vals->{notFoundException}) {
4521 $self->{notFoundException} = $vals->{notFoundException};
4522 }
4523 }
4524 return bless ($self, $classname);
4525 }
4526  
4527 sub getName {
4528 return 'NoteStore_findNotes_result';
4529 }
4530  
4531 sub read {
4532 my ($self, $input) = @_;
4533 my $xfer = 0;
4534 my $fname;
4535 my $ftype = 0;
4536 my $fid = 0;
4537 $xfer += $input->readStructBegin(\$fname);
4538 while (1)
4539 {
4540 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4541 if ($ftype == TType::STOP) {
4542 last;
4543 }
4544 SWITCH: for($fid)
4545 {
4546 /^0$/ && do{ if ($ftype == TType::STRUCT) {
4547 $self->{success} = Net::Evernote::EDAMNoteStore::NoteList->new();
4548 $xfer += $self->{success}->read($input);
4549 } else {
4550 $xfer += $input->skip($ftype);
4551 }
4552 last; };
4553 /^1$/ && do{ if ($ftype == TType::STRUCT) {
4554 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
4555 $xfer += $self->{userException}->read($input);
4556 } else {
4557 $xfer += $input->skip($ftype);
4558 }
4559 last; };
4560 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4561 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
4562 $xfer += $self->{systemException}->read($input);
4563 } else {
4564 $xfer += $input->skip($ftype);
4565 }
4566 last; };
4567 /^3$/ && do{ if ($ftype == TType::STRUCT) {
4568 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
4569 $xfer += $self->{notFoundException}->read($input);
4570 } else {
4571 $xfer += $input->skip($ftype);
4572 }
4573 last; };
4574 $xfer += $input->skip($ftype);
4575 }
4576 $xfer += $input->readFieldEnd();
4577 }
4578 $xfer += $input->readStructEnd();
4579 return $xfer;
4580 }
4581  
4582 sub write {
4583 my ($self, $output) = @_;
4584 my $xfer = 0;
4585 $xfer += $output->writeStructBegin('NoteStore_findNotes_result');
4586 if (defined $self->{success}) {
4587 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
4588 $xfer += $self->{success}->write($output);
4589 $xfer += $output->writeFieldEnd();
4590 }
4591 if (defined $self->{userException}) {
4592 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
4593 $xfer += $self->{userException}->write($output);
4594 $xfer += $output->writeFieldEnd();
4595 }
4596 if (defined $self->{systemException}) {
4597 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
4598 $xfer += $self->{systemException}->write($output);
4599 $xfer += $output->writeFieldEnd();
4600 }
4601 if (defined $self->{notFoundException}) {
4602 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
4603 $xfer += $self->{notFoundException}->write($output);
4604 $xfer += $output->writeFieldEnd();
4605 }
4606 $xfer += $output->writeFieldStop();
4607 $xfer += $output->writeStructEnd();
4608 return $xfer;
4609 }
4610  
4611 package Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args;
4612 use base qw(Class::Accessor);
4613 Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->mk_accessors( qw( authenticationToken filter guid ) );
4614  
4615 sub new {
4616 my $classname = shift;
4617 my $self = {};
4618 my $vals = shift || {};
4619 $self->{authenticationToken} = undef;
4620 $self->{filter} = undef;
4621 $self->{guid} = undef;
4622 if (UNIVERSAL::isa($vals,'HASH')) {
4623 if (defined $vals->{authenticationToken}) {
4624 $self->{authenticationToken} = $vals->{authenticationToken};
4625 }
4626 if (defined $vals->{filter}) {
4627 $self->{filter} = $vals->{filter};
4628 }
4629 if (defined $vals->{guid}) {
4630 $self->{guid} = $vals->{guid};
4631 }
4632 }
4633 return bless ($self, $classname);
4634 }
4635  
4636 sub getName {
4637 return 'NoteStore_findNoteOffset_args';
4638 }
4639  
4640 sub read {
4641 my ($self, $input) = @_;
4642 my $xfer = 0;
4643 my $fname;
4644 my $ftype = 0;
4645 my $fid = 0;
4646 $xfer += $input->readStructBegin(\$fname);
4647 while (1)
4648 {
4649 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4650 if ($ftype == TType::STOP) {
4651 last;
4652 }
4653 SWITCH: for($fid)
4654 {
4655 /^1$/ && do{ if ($ftype == TType::STRING) {
4656 $xfer += $input->readString(\$self->{authenticationToken});
4657 } else {
4658 $xfer += $input->skip($ftype);
4659 }
4660 last; };
4661 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4662 $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
4663 $xfer += $self->{filter}->read($input);
4664 } else {
4665 $xfer += $input->skip($ftype);
4666 }
4667 last; };
4668 /^3$/ && do{ if ($ftype == TType::STRING) {
4669 $xfer += $input->readString(\$self->{guid});
4670 } else {
4671 $xfer += $input->skip($ftype);
4672 }
4673 last; };
4674 $xfer += $input->skip($ftype);
4675 }
4676 $xfer += $input->readFieldEnd();
4677 }
4678 $xfer += $input->readStructEnd();
4679 return $xfer;
4680 }
4681  
4682 sub write {
4683 my ($self, $output) = @_;
4684 my $xfer = 0;
4685 $xfer += $output->writeStructBegin('NoteStore_findNoteOffset_args');
4686 if (defined $self->{authenticationToken}) {
4687 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
4688 $xfer += $output->writeString($self->{authenticationToken});
4689 $xfer += $output->writeFieldEnd();
4690 }
4691 if (defined $self->{filter}) {
4692 $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
4693 $xfer += $self->{filter}->write($output);
4694 $xfer += $output->writeFieldEnd();
4695 }
4696 if (defined $self->{guid}) {
4697 $xfer += $output->writeFieldBegin('guid', TType::STRING, 3);
4698 $xfer += $output->writeString($self->{guid});
4699 $xfer += $output->writeFieldEnd();
4700 }
4701 $xfer += $output->writeFieldStop();
4702 $xfer += $output->writeStructEnd();
4703 return $xfer;
4704 }
4705  
4706 package Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result;
4707 use base qw(Class::Accessor);
4708 Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->mk_accessors( qw( success ) );
4709  
4710 sub new {
4711 my $classname = shift;
4712 my $self = {};
4713 my $vals = shift || {};
4714 $self->{success} = undef;
4715 $self->{userException} = undef;
4716 $self->{systemException} = undef;
4717 $self->{notFoundException} = undef;
4718 if (UNIVERSAL::isa($vals,'HASH')) {
4719 if (defined $vals->{success}) {
4720 $self->{success} = $vals->{success};
4721 }
4722 if (defined $vals->{userException}) {
4723 $self->{userException} = $vals->{userException};
4724 }
4725 if (defined $vals->{systemException}) {
4726 $self->{systemException} = $vals->{systemException};
4727 }
4728 if (defined $vals->{notFoundException}) {
4729 $self->{notFoundException} = $vals->{notFoundException};
4730 }
4731 }
4732 return bless ($self, $classname);
4733 }
4734  
4735 sub getName {
4736 return 'NoteStore_findNoteOffset_result';
4737 }
4738  
4739 sub read {
4740 my ($self, $input) = @_;
4741 my $xfer = 0;
4742 my $fname;
4743 my $ftype = 0;
4744 my $fid = 0;
4745 $xfer += $input->readStructBegin(\$fname);
4746 while (1)
4747 {
4748 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4749 if ($ftype == TType::STOP) {
4750 last;
4751 }
4752 SWITCH: for($fid)
4753 {
4754 /^0$/ && do{ if ($ftype == TType::I32) {
4755 $xfer += $input->readI32(\$self->{success});
4756 } else {
4757 $xfer += $input->skip($ftype);
4758 }
4759 last; };
4760 /^1$/ && do{ if ($ftype == TType::STRUCT) {
4761 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
4762 $xfer += $self->{userException}->read($input);
4763 } else {
4764 $xfer += $input->skip($ftype);
4765 }
4766 last; };
4767 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4768 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
4769 $xfer += $self->{systemException}->read($input);
4770 } else {
4771 $xfer += $input->skip($ftype);
4772 }
4773 last; };
4774 /^3$/ && do{ if ($ftype == TType::STRUCT) {
4775 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
4776 $xfer += $self->{notFoundException}->read($input);
4777 } else {
4778 $xfer += $input->skip($ftype);
4779 }
4780 last; };
4781 $xfer += $input->skip($ftype);
4782 }
4783 $xfer += $input->readFieldEnd();
4784 }
4785 $xfer += $input->readStructEnd();
4786 return $xfer;
4787 }
4788  
4789 sub write {
4790 my ($self, $output) = @_;
4791 my $xfer = 0;
4792 $xfer += $output->writeStructBegin('NoteStore_findNoteOffset_result');
4793 if (defined $self->{success}) {
4794 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
4795 $xfer += $output->writeI32($self->{success});
4796 $xfer += $output->writeFieldEnd();
4797 }
4798 if (defined $self->{userException}) {
4799 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
4800 $xfer += $self->{userException}->write($output);
4801 $xfer += $output->writeFieldEnd();
4802 }
4803 if (defined $self->{systemException}) {
4804 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
4805 $xfer += $self->{systemException}->write($output);
4806 $xfer += $output->writeFieldEnd();
4807 }
4808 if (defined $self->{notFoundException}) {
4809 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
4810 $xfer += $self->{notFoundException}->write($output);
4811 $xfer += $output->writeFieldEnd();
4812 }
4813 $xfer += $output->writeFieldStop();
4814 $xfer += $output->writeStructEnd();
4815 return $xfer;
4816 }
4817  
4818 package Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args;
4819 use base qw(Class::Accessor);
4820 Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->mk_accessors( qw( authenticationToken filter offset maxNotes resultSpec ) );
4821  
4822 sub new {
4823 my $classname = shift;
4824 my $self = {};
4825 my $vals = shift || {};
4826 $self->{authenticationToken} = undef;
4827 $self->{filter} = undef;
4828 $self->{offset} = undef;
4829 $self->{maxNotes} = undef;
4830 $self->{resultSpec} = undef;
4831 if (UNIVERSAL::isa($vals,'HASH')) {
4832 if (defined $vals->{authenticationToken}) {
4833 $self->{authenticationToken} = $vals->{authenticationToken};
4834 }
4835 if (defined $vals->{filter}) {
4836 $self->{filter} = $vals->{filter};
4837 }
4838 if (defined $vals->{offset}) {
4839 $self->{offset} = $vals->{offset};
4840 }
4841 if (defined $vals->{maxNotes}) {
4842 $self->{maxNotes} = $vals->{maxNotes};
4843 }
4844 if (defined $vals->{resultSpec}) {
4845 $self->{resultSpec} = $vals->{resultSpec};
4846 }
4847 }
4848 return bless ($self, $classname);
4849 }
4850  
4851 sub getName {
4852 return 'NoteStore_findNotesMetadata_args';
4853 }
4854  
4855 sub read {
4856 my ($self, $input) = @_;
4857 my $xfer = 0;
4858 my $fname;
4859 my $ftype = 0;
4860 my $fid = 0;
4861 $xfer += $input->readStructBegin(\$fname);
4862 while (1)
4863 {
4864 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4865 if ($ftype == TType::STOP) {
4866 last;
4867 }
4868 SWITCH: for($fid)
4869 {
4870 /^1$/ && do{ if ($ftype == TType::STRING) {
4871 $xfer += $input->readString(\$self->{authenticationToken});
4872 } else {
4873 $xfer += $input->skip($ftype);
4874 }
4875 last; };
4876 /^2$/ && do{ if ($ftype == TType::STRUCT) {
4877 $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
4878 $xfer += $self->{filter}->read($input);
4879 } else {
4880 $xfer += $input->skip($ftype);
4881 }
4882 last; };
4883 /^3$/ && do{ if ($ftype == TType::I32) {
4884 $xfer += $input->readI32(\$self->{offset});
4885 } else {
4886 $xfer += $input->skip($ftype);
4887 }
4888 last; };
4889 /^4$/ && do{ if ($ftype == TType::I32) {
4890 $xfer += $input->readI32(\$self->{maxNotes});
4891 } else {
4892 $xfer += $input->skip($ftype);
4893 }
4894 last; };
4895 /^5$/ && do{ if ($ftype == TType::STRUCT) {
4896 $self->{resultSpec} = Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec->new();
4897 $xfer += $self->{resultSpec}->read($input);
4898 } else {
4899 $xfer += $input->skip($ftype);
4900 }
4901 last; };
4902 $xfer += $input->skip($ftype);
4903 }
4904 $xfer += $input->readFieldEnd();
4905 }
4906 $xfer += $input->readStructEnd();
4907 return $xfer;
4908 }
4909  
4910 sub write {
4911 my ($self, $output) = @_;
4912 my $xfer = 0;
4913 $xfer += $output->writeStructBegin('NoteStore_findNotesMetadata_args');
4914 if (defined $self->{authenticationToken}) {
4915 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
4916 $xfer += $output->writeString($self->{authenticationToken});
4917 $xfer += $output->writeFieldEnd();
4918 }
4919 if (defined $self->{filter}) {
4920 $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
4921 $xfer += $self->{filter}->write($output);
4922 $xfer += $output->writeFieldEnd();
4923 }
4924 if (defined $self->{offset}) {
4925 $xfer += $output->writeFieldBegin('offset', TType::I32, 3);
4926 $xfer += $output->writeI32($self->{offset});
4927 $xfer += $output->writeFieldEnd();
4928 }
4929 if (defined $self->{maxNotes}) {
4930 $xfer += $output->writeFieldBegin('maxNotes', TType::I32, 4);
4931 $xfer += $output->writeI32($self->{maxNotes});
4932 $xfer += $output->writeFieldEnd();
4933 }
4934 if (defined $self->{resultSpec}) {
4935 $xfer += $output->writeFieldBegin('resultSpec', TType::STRUCT, 5);
4936 $xfer += $self->{resultSpec}->write($output);
4937 $xfer += $output->writeFieldEnd();
4938 }
4939 $xfer += $output->writeFieldStop();
4940 $xfer += $output->writeStructEnd();
4941 return $xfer;
4942 }
4943  
4944 package Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result;
4945 use base qw(Class::Accessor);
4946 Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->mk_accessors( qw( success ) );
4947  
4948 sub new {
4949 my $classname = shift;
4950 my $self = {};
4951 my $vals = shift || {};
4952 $self->{success} = undef;
4953 $self->{userException} = undef;
4954 $self->{systemException} = undef;
4955 $self->{notFoundException} = undef;
4956 if (UNIVERSAL::isa($vals,'HASH')) {
4957 if (defined $vals->{success}) {
4958 $self->{success} = $vals->{success};
4959 }
4960 if (defined $vals->{userException}) {
4961 $self->{userException} = $vals->{userException};
4962 }
4963 if (defined $vals->{systemException}) {
4964 $self->{systemException} = $vals->{systemException};
4965 }
4966 if (defined $vals->{notFoundException}) {
4967 $self->{notFoundException} = $vals->{notFoundException};
4968 }
4969 }
4970 return bless ($self, $classname);
4971 }
4972  
4973 sub getName {
4974 return 'NoteStore_findNotesMetadata_result';
4975 }
4976  
4977 sub read {
4978 my ($self, $input) = @_;
4979 my $xfer = 0;
4980 my $fname;
4981 my $ftype = 0;
4982 my $fid = 0;
4983 $xfer += $input->readStructBegin(\$fname);
4984 while (1)
4985 {
4986 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
4987 if ($ftype == TType::STOP) {
4988 last;
4989 }
4990 SWITCH: for($fid)
4991 {
4992 /^0$/ && do{ if ($ftype == TType::STRUCT) {
4993 $self->{success} = Net::Evernote::EDAMNoteStore::NotesMetadataList->new();
4994 $xfer += $self->{success}->read($input);
4995 } else {
4996 $xfer += $input->skip($ftype);
4997 }
4998 last; };
4999 /^1$/ && do{ if ($ftype == TType::STRUCT) {
5000 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
5001 $xfer += $self->{userException}->read($input);
5002 } else {
5003 $xfer += $input->skip($ftype);
5004 }
5005 last; };
5006 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5007 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
5008 $xfer += $self->{systemException}->read($input);
5009 } else {
5010 $xfer += $input->skip($ftype);
5011 }
5012 last; };
5013 /^3$/ && do{ if ($ftype == TType::STRUCT) {
5014 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
5015 $xfer += $self->{notFoundException}->read($input);
5016 } else {
5017 $xfer += $input->skip($ftype);
5018 }
5019 last; };
5020 $xfer += $input->skip($ftype);
5021 }
5022 $xfer += $input->readFieldEnd();
5023 }
5024 $xfer += $input->readStructEnd();
5025 return $xfer;
5026 }
5027  
5028 sub write {
5029 my ($self, $output) = @_;
5030 my $xfer = 0;
5031 $xfer += $output->writeStructBegin('NoteStore_findNotesMetadata_result');
5032 if (defined $self->{success}) {
5033 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
5034 $xfer += $self->{success}->write($output);
5035 $xfer += $output->writeFieldEnd();
5036 }
5037 if (defined $self->{userException}) {
5038 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
5039 $xfer += $self->{userException}->write($output);
5040 $xfer += $output->writeFieldEnd();
5041 }
5042 if (defined $self->{systemException}) {
5043 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
5044 $xfer += $self->{systemException}->write($output);
5045 $xfer += $output->writeFieldEnd();
5046 }
5047 if (defined $self->{notFoundException}) {
5048 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
5049 $xfer += $self->{notFoundException}->write($output);
5050 $xfer += $output->writeFieldEnd();
5051 }
5052 $xfer += $output->writeFieldStop();
5053 $xfer += $output->writeStructEnd();
5054 return $xfer;
5055 }
5056  
5057 package Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args;
5058 use base qw(Class::Accessor);
5059 Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->mk_accessors( qw( authenticationToken filter withTrash ) );
5060  
5061 sub new {
5062 my $classname = shift;
5063 my $self = {};
5064 my $vals = shift || {};
5065 $self->{authenticationToken} = undef;
5066 $self->{filter} = undef;
5067 $self->{withTrash} = undef;
5068 if (UNIVERSAL::isa($vals,'HASH')) {
5069 if (defined $vals->{authenticationToken}) {
5070 $self->{authenticationToken} = $vals->{authenticationToken};
5071 }
5072 if (defined $vals->{filter}) {
5073 $self->{filter} = $vals->{filter};
5074 }
5075 if (defined $vals->{withTrash}) {
5076 $self->{withTrash} = $vals->{withTrash};
5077 }
5078 }
5079 return bless ($self, $classname);
5080 }
5081  
5082 sub getName {
5083 return 'NoteStore_findNoteCounts_args';
5084 }
5085  
5086 sub read {
5087 my ($self, $input) = @_;
5088 my $xfer = 0;
5089 my $fname;
5090 my $ftype = 0;
5091 my $fid = 0;
5092 $xfer += $input->readStructBegin(\$fname);
5093 while (1)
5094 {
5095 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5096 if ($ftype == TType::STOP) {
5097 last;
5098 }
5099 SWITCH: for($fid)
5100 {
5101 /^1$/ && do{ if ($ftype == TType::STRING) {
5102 $xfer += $input->readString(\$self->{authenticationToken});
5103 } else {
5104 $xfer += $input->skip($ftype);
5105 }
5106 last; };
5107 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5108 $self->{filter} = Net::Evernote::EDAMNoteStore::NoteFilter->new();
5109 $xfer += $self->{filter}->read($input);
5110 } else {
5111 $xfer += $input->skip($ftype);
5112 }
5113 last; };
5114 /^3$/ && do{ if ($ftype == TType::BOOL) {
5115 $xfer += $input->readBool(\$self->{withTrash});
5116 } else {
5117 $xfer += $input->skip($ftype);
5118 }
5119 last; };
5120 $xfer += $input->skip($ftype);
5121 }
5122 $xfer += $input->readFieldEnd();
5123 }
5124 $xfer += $input->readStructEnd();
5125 return $xfer;
5126 }
5127  
5128 sub write {
5129 my ($self, $output) = @_;
5130 my $xfer = 0;
5131 $xfer += $output->writeStructBegin('NoteStore_findNoteCounts_args');
5132 if (defined $self->{authenticationToken}) {
5133 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
5134 $xfer += $output->writeString($self->{authenticationToken});
5135 $xfer += $output->writeFieldEnd();
5136 }
5137 if (defined $self->{filter}) {
5138 $xfer += $output->writeFieldBegin('filter', TType::STRUCT, 2);
5139 $xfer += $self->{filter}->write($output);
5140 $xfer += $output->writeFieldEnd();
5141 }
5142 if (defined $self->{withTrash}) {
5143 $xfer += $output->writeFieldBegin('withTrash', TType::BOOL, 3);
5144 $xfer += $output->writeBool($self->{withTrash});
5145 $xfer += $output->writeFieldEnd();
5146 }
5147 $xfer += $output->writeFieldStop();
5148 $xfer += $output->writeStructEnd();
5149 return $xfer;
5150 }
5151  
5152 package Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result;
5153 use base qw(Class::Accessor);
5154 Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->mk_accessors( qw( success ) );
5155  
5156 sub new {
5157 my $classname = shift;
5158 my $self = {};
5159 my $vals = shift || {};
5160 $self->{success} = undef;
5161 $self->{userException} = undef;
5162 $self->{systemException} = undef;
5163 $self->{notFoundException} = undef;
5164 if (UNIVERSAL::isa($vals,'HASH')) {
5165 if (defined $vals->{success}) {
5166 $self->{success} = $vals->{success};
5167 }
5168 if (defined $vals->{userException}) {
5169 $self->{userException} = $vals->{userException};
5170 }
5171 if (defined $vals->{systemException}) {
5172 $self->{systemException} = $vals->{systemException};
5173 }
5174 if (defined $vals->{notFoundException}) {
5175 $self->{notFoundException} = $vals->{notFoundException};
5176 }
5177 }
5178 return bless ($self, $classname);
5179 }
5180  
5181 sub getName {
5182 return 'NoteStore_findNoteCounts_result';
5183 }
5184  
5185 sub read {
5186 my ($self, $input) = @_;
5187 my $xfer = 0;
5188 my $fname;
5189 my $ftype = 0;
5190 my $fid = 0;
5191 $xfer += $input->readStructBegin(\$fname);
5192 while (1)
5193 {
5194 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5195 if ($ftype == TType::STOP) {
5196 last;
5197 }
5198 SWITCH: for($fid)
5199 {
5200 /^0$/ && do{ if ($ftype == TType::STRUCT) {
5201 $self->{success} = Net::Evernote::EDAMNoteStore::NoteCollectionCounts->new();
5202 $xfer += $self->{success}->read($input);
5203 } else {
5204 $xfer += $input->skip($ftype);
5205 }
5206 last; };
5207 /^1$/ && do{ if ($ftype == TType::STRUCT) {
5208 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
5209 $xfer += $self->{userException}->read($input);
5210 } else {
5211 $xfer += $input->skip($ftype);
5212 }
5213 last; };
5214 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5215 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
5216 $xfer += $self->{systemException}->read($input);
5217 } else {
5218 $xfer += $input->skip($ftype);
5219 }
5220 last; };
5221 /^3$/ && do{ if ($ftype == TType::STRUCT) {
5222 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
5223 $xfer += $self->{notFoundException}->read($input);
5224 } else {
5225 $xfer += $input->skip($ftype);
5226 }
5227 last; };
5228 $xfer += $input->skip($ftype);
5229 }
5230 $xfer += $input->readFieldEnd();
5231 }
5232 $xfer += $input->readStructEnd();
5233 return $xfer;
5234 }
5235  
5236 sub write {
5237 my ($self, $output) = @_;
5238 my $xfer = 0;
5239 $xfer += $output->writeStructBegin('NoteStore_findNoteCounts_result');
5240 if (defined $self->{success}) {
5241 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
5242 $xfer += $self->{success}->write($output);
5243 $xfer += $output->writeFieldEnd();
5244 }
5245 if (defined $self->{userException}) {
5246 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
5247 $xfer += $self->{userException}->write($output);
5248 $xfer += $output->writeFieldEnd();
5249 }
5250 if (defined $self->{systemException}) {
5251 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
5252 $xfer += $self->{systemException}->write($output);
5253 $xfer += $output->writeFieldEnd();
5254 }
5255 if (defined $self->{notFoundException}) {
5256 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
5257 $xfer += $self->{notFoundException}->write($output);
5258 $xfer += $output->writeFieldEnd();
5259 }
5260 $xfer += $output->writeFieldStop();
5261 $xfer += $output->writeStructEnd();
5262 return $xfer;
5263 }
5264  
5265 package Net::Evernote::EDAMNoteStore::NoteStore_getNote_args;
5266 use base qw(Class::Accessor);
5267 Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->mk_accessors( qw( authenticationToken guid withContent withResourcesData withResourcesRecognition withResourcesAlternateData ) );
5268  
5269 sub new {
5270 my $classname = shift;
5271 my $self = {};
5272 my $vals = shift || {};
5273 $self->{authenticationToken} = undef;
5274 $self->{guid} = undef;
5275 $self->{withContent} = undef;
5276 $self->{withResourcesData} = undef;
5277 $self->{withResourcesRecognition} = undef;
5278 $self->{withResourcesAlternateData} = undef;
5279 if (UNIVERSAL::isa($vals,'HASH')) {
5280 if (defined $vals->{authenticationToken}) {
5281 $self->{authenticationToken} = $vals->{authenticationToken};
5282 }
5283 if (defined $vals->{guid}) {
5284 $self->{guid} = $vals->{guid};
5285 }
5286 if (defined $vals->{withContent}) {
5287 $self->{withContent} = $vals->{withContent};
5288 }
5289 if (defined $vals->{withResourcesData}) {
5290 $self->{withResourcesData} = $vals->{withResourcesData};
5291 }
5292 if (defined $vals->{withResourcesRecognition}) {
5293 $self->{withResourcesRecognition} = $vals->{withResourcesRecognition};
5294 }
5295 if (defined $vals->{withResourcesAlternateData}) {
5296 $self->{withResourcesAlternateData} = $vals->{withResourcesAlternateData};
5297 }
5298 }
5299 return bless ($self, $classname);
5300 }
5301  
5302 sub getName {
5303 return 'NoteStore_getNote_args';
5304 }
5305  
5306 sub read {
5307 my ($self, $input) = @_;
5308 my $xfer = 0;
5309 my $fname;
5310 my $ftype = 0;
5311 my $fid = 0;
5312 $xfer += $input->readStructBegin(\$fname);
5313 while (1)
5314 {
5315 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5316 if ($ftype == TType::STOP) {
5317 last;
5318 }
5319 SWITCH: for($fid)
5320 {
5321 /^1$/ && do{ if ($ftype == TType::STRING) {
5322 $xfer += $input->readString(\$self->{authenticationToken});
5323 } else {
5324 $xfer += $input->skip($ftype);
5325 }
5326 last; };
5327 /^2$/ && do{ if ($ftype == TType::STRING) {
5328 $xfer += $input->readString(\$self->{guid});
5329 } else {
5330 $xfer += $input->skip($ftype);
5331 }
5332 last; };
5333 /^3$/ && do{ if ($ftype == TType::BOOL) {
5334 $xfer += $input->readBool(\$self->{withContent});
5335 } else {
5336 $xfer += $input->skip($ftype);
5337 }
5338 last; };
5339 /^4$/ && do{ if ($ftype == TType::BOOL) {
5340 $xfer += $input->readBool(\$self->{withResourcesData});
5341 } else {
5342 $xfer += $input->skip($ftype);
5343 }
5344 last; };
5345 /^5$/ && do{ if ($ftype == TType::BOOL) {
5346 $xfer += $input->readBool(\$self->{withResourcesRecognition});
5347 } else {
5348 $xfer += $input->skip($ftype);
5349 }
5350 last; };
5351 /^6$/ && do{ if ($ftype == TType::BOOL) {
5352 $xfer += $input->readBool(\$self->{withResourcesAlternateData});
5353 } else {
5354 $xfer += $input->skip($ftype);
5355 }
5356 last; };
5357 $xfer += $input->skip($ftype);
5358 }
5359 $xfer += $input->readFieldEnd();
5360 }
5361 $xfer += $input->readStructEnd();
5362 return $xfer;
5363 }
5364  
5365 sub write {
5366 my ($self, $output) = @_;
5367 my $xfer = 0;
5368 $xfer += $output->writeStructBegin('NoteStore_getNote_args');
5369 if (defined $self->{authenticationToken}) {
5370 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
5371 $xfer += $output->writeString($self->{authenticationToken});
5372 $xfer += $output->writeFieldEnd();
5373 }
5374 if (defined $self->{guid}) {
5375 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
5376 $xfer += $output->writeString($self->{guid});
5377 $xfer += $output->writeFieldEnd();
5378 }
5379 if (defined $self->{withContent}) {
5380 $xfer += $output->writeFieldBegin('withContent', TType::BOOL, 3);
5381 $xfer += $output->writeBool($self->{withContent});
5382 $xfer += $output->writeFieldEnd();
5383 }
5384 if (defined $self->{withResourcesData}) {
5385 $xfer += $output->writeFieldBegin('withResourcesData', TType::BOOL, 4);
5386 $xfer += $output->writeBool($self->{withResourcesData});
5387 $xfer += $output->writeFieldEnd();
5388 }
5389 if (defined $self->{withResourcesRecognition}) {
5390 $xfer += $output->writeFieldBegin('withResourcesRecognition', TType::BOOL, 5);
5391 $xfer += $output->writeBool($self->{withResourcesRecognition});
5392 $xfer += $output->writeFieldEnd();
5393 }
5394 if (defined $self->{withResourcesAlternateData}) {
5395 $xfer += $output->writeFieldBegin('withResourcesAlternateData', TType::BOOL, 6);
5396 $xfer += $output->writeBool($self->{withResourcesAlternateData});
5397 $xfer += $output->writeFieldEnd();
5398 }
5399 $xfer += $output->writeFieldStop();
5400 $xfer += $output->writeStructEnd();
5401 return $xfer;
5402 }
5403  
5404 package Net::Evernote::EDAMNoteStore::NoteStore_getNote_result;
5405 use base qw(Class::Accessor);
5406 Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->mk_accessors( qw( success ) );
5407  
5408 sub new {
5409 my $classname = shift;
5410 my $self = {};
5411 my $vals = shift || {};
5412 $self->{success} = undef;
5413 $self->{userException} = undef;
5414 $self->{systemException} = undef;
5415 $self->{notFoundException} = undef;
5416 if (UNIVERSAL::isa($vals,'HASH')) {
5417 if (defined $vals->{success}) {
5418 $self->{success} = $vals->{success};
5419 }
5420 if (defined $vals->{userException}) {
5421 $self->{userException} = $vals->{userException};
5422 }
5423 if (defined $vals->{systemException}) {
5424 $self->{systemException} = $vals->{systemException};
5425 }
5426 if (defined $vals->{notFoundException}) {
5427 $self->{notFoundException} = $vals->{notFoundException};
5428 }
5429 }
5430 return bless ($self, $classname);
5431 }
5432  
5433 sub getName {
5434 return 'NoteStore_getNote_result';
5435 }
5436  
5437 sub read {
5438 my ($self, $input) = @_;
5439 my $xfer = 0;
5440 my $fname;
5441 my $ftype = 0;
5442 my $fid = 0;
5443 $xfer += $input->readStructBegin(\$fname);
5444 while (1)
5445 {
5446 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5447 if ($ftype == TType::STOP) {
5448 last;
5449 }
5450 SWITCH: for($fid)
5451 {
5452 /^0$/ && do{ if ($ftype == TType::STRUCT) {
5453 $self->{success} = Net::Evernote::EDAMTypes::Note->new();
5454 $xfer += $self->{success}->read($input);
5455 } else {
5456 $xfer += $input->skip($ftype);
5457 }
5458 last; };
5459 /^1$/ && do{ if ($ftype == TType::STRUCT) {
5460 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
5461 $xfer += $self->{userException}->read($input);
5462 } else {
5463 $xfer += $input->skip($ftype);
5464 }
5465 last; };
5466 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5467 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
5468 $xfer += $self->{systemException}->read($input);
5469 } else {
5470 $xfer += $input->skip($ftype);
5471 }
5472 last; };
5473 /^3$/ && do{ if ($ftype == TType::STRUCT) {
5474 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
5475 $xfer += $self->{notFoundException}->read($input);
5476 } else {
5477 $xfer += $input->skip($ftype);
5478 }
5479 last; };
5480 $xfer += $input->skip($ftype);
5481 }
5482 $xfer += $input->readFieldEnd();
5483 }
5484 $xfer += $input->readStructEnd();
5485 return $xfer;
5486 }
5487  
5488 sub write {
5489 my ($self, $output) = @_;
5490 my $xfer = 0;
5491 $xfer += $output->writeStructBegin('NoteStore_getNote_result');
5492 if (defined $self->{success}) {
5493 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
5494 $xfer += $self->{success}->write($output);
5495 $xfer += $output->writeFieldEnd();
5496 }
5497 if (defined $self->{userException}) {
5498 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
5499 $xfer += $self->{userException}->write($output);
5500 $xfer += $output->writeFieldEnd();
5501 }
5502 if (defined $self->{systemException}) {
5503 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
5504 $xfer += $self->{systemException}->write($output);
5505 $xfer += $output->writeFieldEnd();
5506 }
5507 if (defined $self->{notFoundException}) {
5508 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
5509 $xfer += $self->{notFoundException}->write($output);
5510 $xfer += $output->writeFieldEnd();
5511 }
5512 $xfer += $output->writeFieldStop();
5513 $xfer += $output->writeStructEnd();
5514 return $xfer;
5515 }
5516  
5517 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args;
5518 use base qw(Class::Accessor);
5519 Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->mk_accessors( qw( authenticationToken guid ) );
5520  
5521 sub new {
5522 my $classname = shift;
5523 my $self = {};
5524 my $vals = shift || {};
5525 $self->{authenticationToken} = undef;
5526 $self->{guid} = undef;
5527 if (UNIVERSAL::isa($vals,'HASH')) {
5528 if (defined $vals->{authenticationToken}) {
5529 $self->{authenticationToken} = $vals->{authenticationToken};
5530 }
5531 if (defined $vals->{guid}) {
5532 $self->{guid} = $vals->{guid};
5533 }
5534 }
5535 return bless ($self, $classname);
5536 }
5537  
5538 sub getName {
5539 return 'NoteStore_getNoteApplicationData_args';
5540 }
5541  
5542 sub read {
5543 my ($self, $input) = @_;
5544 my $xfer = 0;
5545 my $fname;
5546 my $ftype = 0;
5547 my $fid = 0;
5548 $xfer += $input->readStructBegin(\$fname);
5549 while (1)
5550 {
5551 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5552 if ($ftype == TType::STOP) {
5553 last;
5554 }
5555 SWITCH: for($fid)
5556 {
5557 /^1$/ && do{ if ($ftype == TType::STRING) {
5558 $xfer += $input->readString(\$self->{authenticationToken});
5559 } else {
5560 $xfer += $input->skip($ftype);
5561 }
5562 last; };
5563 /^2$/ && do{ if ($ftype == TType::STRING) {
5564 $xfer += $input->readString(\$self->{guid});
5565 } else {
5566 $xfer += $input->skip($ftype);
5567 }
5568 last; };
5569 $xfer += $input->skip($ftype);
5570 }
5571 $xfer += $input->readFieldEnd();
5572 }
5573 $xfer += $input->readStructEnd();
5574 return $xfer;
5575 }
5576  
5577 sub write {
5578 my ($self, $output) = @_;
5579 my $xfer = 0;
5580 $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationData_args');
5581 if (defined $self->{authenticationToken}) {
5582 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
5583 $xfer += $output->writeString($self->{authenticationToken});
5584 $xfer += $output->writeFieldEnd();
5585 }
5586 if (defined $self->{guid}) {
5587 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
5588 $xfer += $output->writeString($self->{guid});
5589 $xfer += $output->writeFieldEnd();
5590 }
5591 $xfer += $output->writeFieldStop();
5592 $xfer += $output->writeStructEnd();
5593 return $xfer;
5594 }
5595  
5596 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result;
5597 use base qw(Class::Accessor);
5598 Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->mk_accessors( qw( success ) );
5599  
5600 sub new {
5601 my $classname = shift;
5602 my $self = {};
5603 my $vals = shift || {};
5604 $self->{success} = undef;
5605 $self->{userException} = undef;
5606 $self->{systemException} = undef;
5607 $self->{notFoundException} = undef;
5608 if (UNIVERSAL::isa($vals,'HASH')) {
5609 if (defined $vals->{success}) {
5610 $self->{success} = $vals->{success};
5611 }
5612 if (defined $vals->{userException}) {
5613 $self->{userException} = $vals->{userException};
5614 }
5615 if (defined $vals->{systemException}) {
5616 $self->{systemException} = $vals->{systemException};
5617 }
5618 if (defined $vals->{notFoundException}) {
5619 $self->{notFoundException} = $vals->{notFoundException};
5620 }
5621 }
5622 return bless ($self, $classname);
5623 }
5624  
5625 sub getName {
5626 return 'NoteStore_getNoteApplicationData_result';
5627 }
5628  
5629 sub read {
5630 my ($self, $input) = @_;
5631 my $xfer = 0;
5632 my $fname;
5633 my $ftype = 0;
5634 my $fid = 0;
5635 $xfer += $input->readStructBegin(\$fname);
5636 while (1)
5637 {
5638 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5639 if ($ftype == TType::STOP) {
5640 last;
5641 }
5642 SWITCH: for($fid)
5643 {
5644 /^0$/ && do{ if ($ftype == TType::STRUCT) {
5645 $self->{success} = Net::Evernote::EDAMTypes::LazyMap->new();
5646 $xfer += $self->{success}->read($input);
5647 } else {
5648 $xfer += $input->skip($ftype);
5649 }
5650 last; };
5651 /^1$/ && do{ if ($ftype == TType::STRUCT) {
5652 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
5653 $xfer += $self->{userException}->read($input);
5654 } else {
5655 $xfer += $input->skip($ftype);
5656 }
5657 last; };
5658 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5659 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
5660 $xfer += $self->{systemException}->read($input);
5661 } else {
5662 $xfer += $input->skip($ftype);
5663 }
5664 last; };
5665 /^3$/ && do{ if ($ftype == TType::STRUCT) {
5666 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
5667 $xfer += $self->{notFoundException}->read($input);
5668 } else {
5669 $xfer += $input->skip($ftype);
5670 }
5671 last; };
5672 $xfer += $input->skip($ftype);
5673 }
5674 $xfer += $input->readFieldEnd();
5675 }
5676 $xfer += $input->readStructEnd();
5677 return $xfer;
5678 }
5679  
5680 sub write {
5681 my ($self, $output) = @_;
5682 my $xfer = 0;
5683 $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationData_result');
5684 if (defined $self->{success}) {
5685 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
5686 $xfer += $self->{success}->write($output);
5687 $xfer += $output->writeFieldEnd();
5688 }
5689 if (defined $self->{userException}) {
5690 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
5691 $xfer += $self->{userException}->write($output);
5692 $xfer += $output->writeFieldEnd();
5693 }
5694 if (defined $self->{systemException}) {
5695 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
5696 $xfer += $self->{systemException}->write($output);
5697 $xfer += $output->writeFieldEnd();
5698 }
5699 if (defined $self->{notFoundException}) {
5700 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
5701 $xfer += $self->{notFoundException}->write($output);
5702 $xfer += $output->writeFieldEnd();
5703 }
5704 $xfer += $output->writeFieldStop();
5705 $xfer += $output->writeStructEnd();
5706 return $xfer;
5707 }
5708  
5709 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args;
5710 use base qw(Class::Accessor);
5711 Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );
5712  
5713 sub new {
5714 my $classname = shift;
5715 my $self = {};
5716 my $vals = shift || {};
5717 $self->{authenticationToken} = undef;
5718 $self->{guid} = undef;
5719 $self->{key} = undef;
5720 if (UNIVERSAL::isa($vals,'HASH')) {
5721 if (defined $vals->{authenticationToken}) {
5722 $self->{authenticationToken} = $vals->{authenticationToken};
5723 }
5724 if (defined $vals->{guid}) {
5725 $self->{guid} = $vals->{guid};
5726 }
5727 if (defined $vals->{key}) {
5728 $self->{key} = $vals->{key};
5729 }
5730 }
5731 return bless ($self, $classname);
5732 }
5733  
5734 sub getName {
5735 return 'NoteStore_getNoteApplicationDataEntry_args';
5736 }
5737  
5738 sub read {
5739 my ($self, $input) = @_;
5740 my $xfer = 0;
5741 my $fname;
5742 my $ftype = 0;
5743 my $fid = 0;
5744 $xfer += $input->readStructBegin(\$fname);
5745 while (1)
5746 {
5747 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5748 if ($ftype == TType::STOP) {
5749 last;
5750 }
5751 SWITCH: for($fid)
5752 {
5753 /^1$/ && do{ if ($ftype == TType::STRING) {
5754 $xfer += $input->readString(\$self->{authenticationToken});
5755 } else {
5756 $xfer += $input->skip($ftype);
5757 }
5758 last; };
5759 /^2$/ && do{ if ($ftype == TType::STRING) {
5760 $xfer += $input->readString(\$self->{guid});
5761 } else {
5762 $xfer += $input->skip($ftype);
5763 }
5764 last; };
5765 /^3$/ && do{ if ($ftype == TType::STRING) {
5766 $xfer += $input->readString(\$self->{key});
5767 } else {
5768 $xfer += $input->skip($ftype);
5769 }
5770 last; };
5771 $xfer += $input->skip($ftype);
5772 }
5773 $xfer += $input->readFieldEnd();
5774 }
5775 $xfer += $input->readStructEnd();
5776 return $xfer;
5777 }
5778  
5779 sub write {
5780 my ($self, $output) = @_;
5781 my $xfer = 0;
5782 $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationDataEntry_args');
5783 if (defined $self->{authenticationToken}) {
5784 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
5785 $xfer += $output->writeString($self->{authenticationToken});
5786 $xfer += $output->writeFieldEnd();
5787 }
5788 if (defined $self->{guid}) {
5789 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
5790 $xfer += $output->writeString($self->{guid});
5791 $xfer += $output->writeFieldEnd();
5792 }
5793 if (defined $self->{key}) {
5794 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
5795 $xfer += $output->writeString($self->{key});
5796 $xfer += $output->writeFieldEnd();
5797 }
5798 $xfer += $output->writeFieldStop();
5799 $xfer += $output->writeStructEnd();
5800 return $xfer;
5801 }
5802  
5803 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result;
5804 use base qw(Class::Accessor);
5805 Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->mk_accessors( qw( success ) );
5806  
5807 sub new {
5808 my $classname = shift;
5809 my $self = {};
5810 my $vals = shift || {};
5811 $self->{success} = undef;
5812 $self->{userException} = undef;
5813 $self->{systemException} = undef;
5814 $self->{notFoundException} = undef;
5815 if (UNIVERSAL::isa($vals,'HASH')) {
5816 if (defined $vals->{success}) {
5817 $self->{success} = $vals->{success};
5818 }
5819 if (defined $vals->{userException}) {
5820 $self->{userException} = $vals->{userException};
5821 }
5822 if (defined $vals->{systemException}) {
5823 $self->{systemException} = $vals->{systemException};
5824 }
5825 if (defined $vals->{notFoundException}) {
5826 $self->{notFoundException} = $vals->{notFoundException};
5827 }
5828 }
5829 return bless ($self, $classname);
5830 }
5831  
5832 sub getName {
5833 return 'NoteStore_getNoteApplicationDataEntry_result';
5834 }
5835  
5836 sub read {
5837 my ($self, $input) = @_;
5838 my $xfer = 0;
5839 my $fname;
5840 my $ftype = 0;
5841 my $fid = 0;
5842 $xfer += $input->readStructBegin(\$fname);
5843 while (1)
5844 {
5845 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5846 if ($ftype == TType::STOP) {
5847 last;
5848 }
5849 SWITCH: for($fid)
5850 {
5851 /^0$/ && do{ if ($ftype == TType::STRING) {
5852 $xfer += $input->readString(\$self->{success});
5853 } else {
5854 $xfer += $input->skip($ftype);
5855 }
5856 last; };
5857 /^1$/ && do{ if ($ftype == TType::STRUCT) {
5858 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
5859 $xfer += $self->{userException}->read($input);
5860 } else {
5861 $xfer += $input->skip($ftype);
5862 }
5863 last; };
5864 /^2$/ && do{ if ($ftype == TType::STRUCT) {
5865 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
5866 $xfer += $self->{systemException}->read($input);
5867 } else {
5868 $xfer += $input->skip($ftype);
5869 }
5870 last; };
5871 /^3$/ && do{ if ($ftype == TType::STRUCT) {
5872 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
5873 $xfer += $self->{notFoundException}->read($input);
5874 } else {
5875 $xfer += $input->skip($ftype);
5876 }
5877 last; };
5878 $xfer += $input->skip($ftype);
5879 }
5880 $xfer += $input->readFieldEnd();
5881 }
5882 $xfer += $input->readStructEnd();
5883 return $xfer;
5884 }
5885  
5886 sub write {
5887 my ($self, $output) = @_;
5888 my $xfer = 0;
5889 $xfer += $output->writeStructBegin('NoteStore_getNoteApplicationDataEntry_result');
5890 if (defined $self->{success}) {
5891 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
5892 $xfer += $output->writeString($self->{success});
5893 $xfer += $output->writeFieldEnd();
5894 }
5895 if (defined $self->{userException}) {
5896 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
5897 $xfer += $self->{userException}->write($output);
5898 $xfer += $output->writeFieldEnd();
5899 }
5900 if (defined $self->{systemException}) {
5901 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
5902 $xfer += $self->{systemException}->write($output);
5903 $xfer += $output->writeFieldEnd();
5904 }
5905 if (defined $self->{notFoundException}) {
5906 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
5907 $xfer += $self->{notFoundException}->write($output);
5908 $xfer += $output->writeFieldEnd();
5909 }
5910 $xfer += $output->writeFieldStop();
5911 $xfer += $output->writeStructEnd();
5912 return $xfer;
5913 }
5914  
5915 package Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args;
5916 use base qw(Class::Accessor);
5917 Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key value ) );
5918  
5919 sub new {
5920 my $classname = shift;
5921 my $self = {};
5922 my $vals = shift || {};
5923 $self->{authenticationToken} = undef;
5924 $self->{guid} = undef;
5925 $self->{key} = undef;
5926 $self->{value} = undef;
5927 if (UNIVERSAL::isa($vals,'HASH')) {
5928 if (defined $vals->{authenticationToken}) {
5929 $self->{authenticationToken} = $vals->{authenticationToken};
5930 }
5931 if (defined $vals->{guid}) {
5932 $self->{guid} = $vals->{guid};
5933 }
5934 if (defined $vals->{key}) {
5935 $self->{key} = $vals->{key};
5936 }
5937 if (defined $vals->{value}) {
5938 $self->{value} = $vals->{value};
5939 }
5940 }
5941 return bless ($self, $classname);
5942 }
5943  
5944 sub getName {
5945 return 'NoteStore_setNoteApplicationDataEntry_args';
5946 }
5947  
5948 sub read {
5949 my ($self, $input) = @_;
5950 my $xfer = 0;
5951 my $fname;
5952 my $ftype = 0;
5953 my $fid = 0;
5954 $xfer += $input->readStructBegin(\$fname);
5955 while (1)
5956 {
5957 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
5958 if ($ftype == TType::STOP) {
5959 last;
5960 }
5961 SWITCH: for($fid)
5962 {
5963 /^1$/ && do{ if ($ftype == TType::STRING) {
5964 $xfer += $input->readString(\$self->{authenticationToken});
5965 } else {
5966 $xfer += $input->skip($ftype);
5967 }
5968 last; };
5969 /^2$/ && do{ if ($ftype == TType::STRING) {
5970 $xfer += $input->readString(\$self->{guid});
5971 } else {
5972 $xfer += $input->skip($ftype);
5973 }
5974 last; };
5975 /^3$/ && do{ if ($ftype == TType::STRING) {
5976 $xfer += $input->readString(\$self->{key});
5977 } else {
5978 $xfer += $input->skip($ftype);
5979 }
5980 last; };
5981 /^4$/ && do{ if ($ftype == TType::STRING) {
5982 $xfer += $input->readString(\$self->{value});
5983 } else {
5984 $xfer += $input->skip($ftype);
5985 }
5986 last; };
5987 $xfer += $input->skip($ftype);
5988 }
5989 $xfer += $input->readFieldEnd();
5990 }
5991 $xfer += $input->readStructEnd();
5992 return $xfer;
5993 }
5994  
5995 sub write {
5996 my ($self, $output) = @_;
5997 my $xfer = 0;
5998 $xfer += $output->writeStructBegin('NoteStore_setNoteApplicationDataEntry_args');
5999 if (defined $self->{authenticationToken}) {
6000 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
6001 $xfer += $output->writeString($self->{authenticationToken});
6002 $xfer += $output->writeFieldEnd();
6003 }
6004 if (defined $self->{guid}) {
6005 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
6006 $xfer += $output->writeString($self->{guid});
6007 $xfer += $output->writeFieldEnd();
6008 }
6009 if (defined $self->{key}) {
6010 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
6011 $xfer += $output->writeString($self->{key});
6012 $xfer += $output->writeFieldEnd();
6013 }
6014 if (defined $self->{value}) {
6015 $xfer += $output->writeFieldBegin('value', TType::STRING, 4);
6016 $xfer += $output->writeString($self->{value});
6017 $xfer += $output->writeFieldEnd();
6018 }
6019 $xfer += $output->writeFieldStop();
6020 $xfer += $output->writeStructEnd();
6021 return $xfer;
6022 }
6023  
6024 package Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result;
6025 use base qw(Class::Accessor);
6026 Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->mk_accessors( qw( success ) );
6027  
6028 sub new {
6029 my $classname = shift;
6030 my $self = {};
6031 my $vals = shift || {};
6032 $self->{success} = undef;
6033 $self->{userException} = undef;
6034 $self->{systemException} = undef;
6035 $self->{notFoundException} = undef;
6036 if (UNIVERSAL::isa($vals,'HASH')) {
6037 if (defined $vals->{success}) {
6038 $self->{success} = $vals->{success};
6039 }
6040 if (defined $vals->{userException}) {
6041 $self->{userException} = $vals->{userException};
6042 }
6043 if (defined $vals->{systemException}) {
6044 $self->{systemException} = $vals->{systemException};
6045 }
6046 if (defined $vals->{notFoundException}) {
6047 $self->{notFoundException} = $vals->{notFoundException};
6048 }
6049 }
6050 return bless ($self, $classname);
6051 }
6052  
6053 sub getName {
6054 return 'NoteStore_setNoteApplicationDataEntry_result';
6055 }
6056  
6057 sub read {
6058 my ($self, $input) = @_;
6059 my $xfer = 0;
6060 my $fname;
6061 my $ftype = 0;
6062 my $fid = 0;
6063 $xfer += $input->readStructBegin(\$fname);
6064 while (1)
6065 {
6066 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6067 if ($ftype == TType::STOP) {
6068 last;
6069 }
6070 SWITCH: for($fid)
6071 {
6072 /^0$/ && do{ if ($ftype == TType::I32) {
6073 $xfer += $input->readI32(\$self->{success});
6074 } else {
6075 $xfer += $input->skip($ftype);
6076 }
6077 last; };
6078 /^1$/ && do{ if ($ftype == TType::STRUCT) {
6079 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
6080 $xfer += $self->{userException}->read($input);
6081 } else {
6082 $xfer += $input->skip($ftype);
6083 }
6084 last; };
6085 /^2$/ && do{ if ($ftype == TType::STRUCT) {
6086 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
6087 $xfer += $self->{systemException}->read($input);
6088 } else {
6089 $xfer += $input->skip($ftype);
6090 }
6091 last; };
6092 /^3$/ && do{ if ($ftype == TType::STRUCT) {
6093 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
6094 $xfer += $self->{notFoundException}->read($input);
6095 } else {
6096 $xfer += $input->skip($ftype);
6097 }
6098 last; };
6099 $xfer += $input->skip($ftype);
6100 }
6101 $xfer += $input->readFieldEnd();
6102 }
6103 $xfer += $input->readStructEnd();
6104 return $xfer;
6105 }
6106  
6107 sub write {
6108 my ($self, $output) = @_;
6109 my $xfer = 0;
6110 $xfer += $output->writeStructBegin('NoteStore_setNoteApplicationDataEntry_result');
6111 if (defined $self->{success}) {
6112 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
6113 $xfer += $output->writeI32($self->{success});
6114 $xfer += $output->writeFieldEnd();
6115 }
6116 if (defined $self->{userException}) {
6117 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
6118 $xfer += $self->{userException}->write($output);
6119 $xfer += $output->writeFieldEnd();
6120 }
6121 if (defined $self->{systemException}) {
6122 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
6123 $xfer += $self->{systemException}->write($output);
6124 $xfer += $output->writeFieldEnd();
6125 }
6126 if (defined $self->{notFoundException}) {
6127 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
6128 $xfer += $self->{notFoundException}->write($output);
6129 $xfer += $output->writeFieldEnd();
6130 }
6131 $xfer += $output->writeFieldStop();
6132 $xfer += $output->writeStructEnd();
6133 return $xfer;
6134 }
6135  
6136 package Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args;
6137 use base qw(Class::Accessor);
6138 Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );
6139  
6140 sub new {
6141 my $classname = shift;
6142 my $self = {};
6143 my $vals = shift || {};
6144 $self->{authenticationToken} = undef;
6145 $self->{guid} = undef;
6146 $self->{key} = undef;
6147 if (UNIVERSAL::isa($vals,'HASH')) {
6148 if (defined $vals->{authenticationToken}) {
6149 $self->{authenticationToken} = $vals->{authenticationToken};
6150 }
6151 if (defined $vals->{guid}) {
6152 $self->{guid} = $vals->{guid};
6153 }
6154 if (defined $vals->{key}) {
6155 $self->{key} = $vals->{key};
6156 }
6157 }
6158 return bless ($self, $classname);
6159 }
6160  
6161 sub getName {
6162 return 'NoteStore_unsetNoteApplicationDataEntry_args';
6163 }
6164  
6165 sub read {
6166 my ($self, $input) = @_;
6167 my $xfer = 0;
6168 my $fname;
6169 my $ftype = 0;
6170 my $fid = 0;
6171 $xfer += $input->readStructBegin(\$fname);
6172 while (1)
6173 {
6174 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6175 if ($ftype == TType::STOP) {
6176 last;
6177 }
6178 SWITCH: for($fid)
6179 {
6180 /^1$/ && do{ if ($ftype == TType::STRING) {
6181 $xfer += $input->readString(\$self->{authenticationToken});
6182 } else {
6183 $xfer += $input->skip($ftype);
6184 }
6185 last; };
6186 /^2$/ && do{ if ($ftype == TType::STRING) {
6187 $xfer += $input->readString(\$self->{guid});
6188 } else {
6189 $xfer += $input->skip($ftype);
6190 }
6191 last; };
6192 /^3$/ && do{ if ($ftype == TType::STRING) {
6193 $xfer += $input->readString(\$self->{key});
6194 } else {
6195 $xfer += $input->skip($ftype);
6196 }
6197 last; };
6198 $xfer += $input->skip($ftype);
6199 }
6200 $xfer += $input->readFieldEnd();
6201 }
6202 $xfer += $input->readStructEnd();
6203 return $xfer;
6204 }
6205  
6206 sub write {
6207 my ($self, $output) = @_;
6208 my $xfer = 0;
6209 $xfer += $output->writeStructBegin('NoteStore_unsetNoteApplicationDataEntry_args');
6210 if (defined $self->{authenticationToken}) {
6211 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
6212 $xfer += $output->writeString($self->{authenticationToken});
6213 $xfer += $output->writeFieldEnd();
6214 }
6215 if (defined $self->{guid}) {
6216 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
6217 $xfer += $output->writeString($self->{guid});
6218 $xfer += $output->writeFieldEnd();
6219 }
6220 if (defined $self->{key}) {
6221 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
6222 $xfer += $output->writeString($self->{key});
6223 $xfer += $output->writeFieldEnd();
6224 }
6225 $xfer += $output->writeFieldStop();
6226 $xfer += $output->writeStructEnd();
6227 return $xfer;
6228 }
6229  
6230 package Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result;
6231 use base qw(Class::Accessor);
6232 Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->mk_accessors( qw( success ) );
6233  
6234 sub new {
6235 my $classname = shift;
6236 my $self = {};
6237 my $vals = shift || {};
6238 $self->{success} = undef;
6239 $self->{userException} = undef;
6240 $self->{systemException} = undef;
6241 $self->{notFoundException} = undef;
6242 if (UNIVERSAL::isa($vals,'HASH')) {
6243 if (defined $vals->{success}) {
6244 $self->{success} = $vals->{success};
6245 }
6246 if (defined $vals->{userException}) {
6247 $self->{userException} = $vals->{userException};
6248 }
6249 if (defined $vals->{systemException}) {
6250 $self->{systemException} = $vals->{systemException};
6251 }
6252 if (defined $vals->{notFoundException}) {
6253 $self->{notFoundException} = $vals->{notFoundException};
6254 }
6255 }
6256 return bless ($self, $classname);
6257 }
6258  
6259 sub getName {
6260 return 'NoteStore_unsetNoteApplicationDataEntry_result';
6261 }
6262  
6263 sub read {
6264 my ($self, $input) = @_;
6265 my $xfer = 0;
6266 my $fname;
6267 my $ftype = 0;
6268 my $fid = 0;
6269 $xfer += $input->readStructBegin(\$fname);
6270 while (1)
6271 {
6272 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6273 if ($ftype == TType::STOP) {
6274 last;
6275 }
6276 SWITCH: for($fid)
6277 {
6278 /^0$/ && do{ if ($ftype == TType::I32) {
6279 $xfer += $input->readI32(\$self->{success});
6280 } else {
6281 $xfer += $input->skip($ftype);
6282 }
6283 last; };
6284 /^1$/ && do{ if ($ftype == TType::STRUCT) {
6285 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
6286 $xfer += $self->{userException}->read($input);
6287 } else {
6288 $xfer += $input->skip($ftype);
6289 }
6290 last; };
6291 /^2$/ && do{ if ($ftype == TType::STRUCT) {
6292 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
6293 $xfer += $self->{systemException}->read($input);
6294 } else {
6295 $xfer += $input->skip($ftype);
6296 }
6297 last; };
6298 /^3$/ && do{ if ($ftype == TType::STRUCT) {
6299 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
6300 $xfer += $self->{notFoundException}->read($input);
6301 } else {
6302 $xfer += $input->skip($ftype);
6303 }
6304 last; };
6305 $xfer += $input->skip($ftype);
6306 }
6307 $xfer += $input->readFieldEnd();
6308 }
6309 $xfer += $input->readStructEnd();
6310 return $xfer;
6311 }
6312  
6313 sub write {
6314 my ($self, $output) = @_;
6315 my $xfer = 0;
6316 $xfer += $output->writeStructBegin('NoteStore_unsetNoteApplicationDataEntry_result');
6317 if (defined $self->{success}) {
6318 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
6319 $xfer += $output->writeI32($self->{success});
6320 $xfer += $output->writeFieldEnd();
6321 }
6322 if (defined $self->{userException}) {
6323 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
6324 $xfer += $self->{userException}->write($output);
6325 $xfer += $output->writeFieldEnd();
6326 }
6327 if (defined $self->{systemException}) {
6328 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
6329 $xfer += $self->{systemException}->write($output);
6330 $xfer += $output->writeFieldEnd();
6331 }
6332 if (defined $self->{notFoundException}) {
6333 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
6334 $xfer += $self->{notFoundException}->write($output);
6335 $xfer += $output->writeFieldEnd();
6336 }
6337 $xfer += $output->writeFieldStop();
6338 $xfer += $output->writeStructEnd();
6339 return $xfer;
6340 }
6341  
6342 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args;
6343 use base qw(Class::Accessor);
6344 Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->mk_accessors( qw( authenticationToken guid ) );
6345  
6346 sub new {
6347 my $classname = shift;
6348 my $self = {};
6349 my $vals = shift || {};
6350 $self->{authenticationToken} = undef;
6351 $self->{guid} = undef;
6352 if (UNIVERSAL::isa($vals,'HASH')) {
6353 if (defined $vals->{authenticationToken}) {
6354 $self->{authenticationToken} = $vals->{authenticationToken};
6355 }
6356 if (defined $vals->{guid}) {
6357 $self->{guid} = $vals->{guid};
6358 }
6359 }
6360 return bless ($self, $classname);
6361 }
6362  
6363 sub getName {
6364 return 'NoteStore_getNoteContent_args';
6365 }
6366  
6367 sub read {
6368 my ($self, $input) = @_;
6369 my $xfer = 0;
6370 my $fname;
6371 my $ftype = 0;
6372 my $fid = 0;
6373 $xfer += $input->readStructBegin(\$fname);
6374 while (1)
6375 {
6376 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6377 if ($ftype == TType::STOP) {
6378 last;
6379 }
6380 SWITCH: for($fid)
6381 {
6382 /^1$/ && do{ if ($ftype == TType::STRING) {
6383 $xfer += $input->readString(\$self->{authenticationToken});
6384 } else {
6385 $xfer += $input->skip($ftype);
6386 }
6387 last; };
6388 /^2$/ && do{ if ($ftype == TType::STRING) {
6389 $xfer += $input->readString(\$self->{guid});
6390 } else {
6391 $xfer += $input->skip($ftype);
6392 }
6393 last; };
6394 $xfer += $input->skip($ftype);
6395 }
6396 $xfer += $input->readFieldEnd();
6397 }
6398 $xfer += $input->readStructEnd();
6399 return $xfer;
6400 }
6401  
6402 sub write {
6403 my ($self, $output) = @_;
6404 my $xfer = 0;
6405 $xfer += $output->writeStructBegin('NoteStore_getNoteContent_args');
6406 if (defined $self->{authenticationToken}) {
6407 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
6408 $xfer += $output->writeString($self->{authenticationToken});
6409 $xfer += $output->writeFieldEnd();
6410 }
6411 if (defined $self->{guid}) {
6412 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
6413 $xfer += $output->writeString($self->{guid});
6414 $xfer += $output->writeFieldEnd();
6415 }
6416 $xfer += $output->writeFieldStop();
6417 $xfer += $output->writeStructEnd();
6418 return $xfer;
6419 }
6420  
6421 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result;
6422 use base qw(Class::Accessor);
6423 Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->mk_accessors( qw( success ) );
6424  
6425 sub new {
6426 my $classname = shift;
6427 my $self = {};
6428 my $vals = shift || {};
6429 $self->{success} = undef;
6430 $self->{userException} = undef;
6431 $self->{systemException} = undef;
6432 $self->{notFoundException} = undef;
6433 if (UNIVERSAL::isa($vals,'HASH')) {
6434 if (defined $vals->{success}) {
6435 $self->{success} = $vals->{success};
6436 }
6437 if (defined $vals->{userException}) {
6438 $self->{userException} = $vals->{userException};
6439 }
6440 if (defined $vals->{systemException}) {
6441 $self->{systemException} = $vals->{systemException};
6442 }
6443 if (defined $vals->{notFoundException}) {
6444 $self->{notFoundException} = $vals->{notFoundException};
6445 }
6446 }
6447 return bless ($self, $classname);
6448 }
6449  
6450 sub getName {
6451 return 'NoteStore_getNoteContent_result';
6452 }
6453  
6454 sub read {
6455 my ($self, $input) = @_;
6456 my $xfer = 0;
6457 my $fname;
6458 my $ftype = 0;
6459 my $fid = 0;
6460 $xfer += $input->readStructBegin(\$fname);
6461 while (1)
6462 {
6463 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6464 if ($ftype == TType::STOP) {
6465 last;
6466 }
6467 SWITCH: for($fid)
6468 {
6469 /^0$/ && do{ if ($ftype == TType::STRING) {
6470 $xfer += $input->readString(\$self->{success});
6471 } else {
6472 $xfer += $input->skip($ftype);
6473 }
6474 last; };
6475 /^1$/ && do{ if ($ftype == TType::STRUCT) {
6476 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
6477 $xfer += $self->{userException}->read($input);
6478 } else {
6479 $xfer += $input->skip($ftype);
6480 }
6481 last; };
6482 /^2$/ && do{ if ($ftype == TType::STRUCT) {
6483 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
6484 $xfer += $self->{systemException}->read($input);
6485 } else {
6486 $xfer += $input->skip($ftype);
6487 }
6488 last; };
6489 /^3$/ && do{ if ($ftype == TType::STRUCT) {
6490 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
6491 $xfer += $self->{notFoundException}->read($input);
6492 } else {
6493 $xfer += $input->skip($ftype);
6494 }
6495 last; };
6496 $xfer += $input->skip($ftype);
6497 }
6498 $xfer += $input->readFieldEnd();
6499 }
6500 $xfer += $input->readStructEnd();
6501 return $xfer;
6502 }
6503  
6504 sub write {
6505 my ($self, $output) = @_;
6506 my $xfer = 0;
6507 $xfer += $output->writeStructBegin('NoteStore_getNoteContent_result');
6508 if (defined $self->{success}) {
6509 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
6510 $xfer += $output->writeString($self->{success});
6511 $xfer += $output->writeFieldEnd();
6512 }
6513 if (defined $self->{userException}) {
6514 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
6515 $xfer += $self->{userException}->write($output);
6516 $xfer += $output->writeFieldEnd();
6517 }
6518 if (defined $self->{systemException}) {
6519 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
6520 $xfer += $self->{systemException}->write($output);
6521 $xfer += $output->writeFieldEnd();
6522 }
6523 if (defined $self->{notFoundException}) {
6524 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
6525 $xfer += $self->{notFoundException}->write($output);
6526 $xfer += $output->writeFieldEnd();
6527 }
6528 $xfer += $output->writeFieldStop();
6529 $xfer += $output->writeStructEnd();
6530 return $xfer;
6531 }
6532  
6533 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args;
6534 use base qw(Class::Accessor);
6535 Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->mk_accessors( qw( authenticationToken guid noteOnly tokenizeForIndexing ) );
6536  
6537 sub new {
6538 my $classname = shift;
6539 my $self = {};
6540 my $vals = shift || {};
6541 $self->{authenticationToken} = undef;
6542 $self->{guid} = undef;
6543 $self->{noteOnly} = undef;
6544 $self->{tokenizeForIndexing} = undef;
6545 if (UNIVERSAL::isa($vals,'HASH')) {
6546 if (defined $vals->{authenticationToken}) {
6547 $self->{authenticationToken} = $vals->{authenticationToken};
6548 }
6549 if (defined $vals->{guid}) {
6550 $self->{guid} = $vals->{guid};
6551 }
6552 if (defined $vals->{noteOnly}) {
6553 $self->{noteOnly} = $vals->{noteOnly};
6554 }
6555 if (defined $vals->{tokenizeForIndexing}) {
6556 $self->{tokenizeForIndexing} = $vals->{tokenizeForIndexing};
6557 }
6558 }
6559 return bless ($self, $classname);
6560 }
6561  
6562 sub getName {
6563 return 'NoteStore_getNoteSearchText_args';
6564 }
6565  
6566 sub read {
6567 my ($self, $input) = @_;
6568 my $xfer = 0;
6569 my $fname;
6570 my $ftype = 0;
6571 my $fid = 0;
6572 $xfer += $input->readStructBegin(\$fname);
6573 while (1)
6574 {
6575 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6576 if ($ftype == TType::STOP) {
6577 last;
6578 }
6579 SWITCH: for($fid)
6580 {
6581 /^1$/ && do{ if ($ftype == TType::STRING) {
6582 $xfer += $input->readString(\$self->{authenticationToken});
6583 } else {
6584 $xfer += $input->skip($ftype);
6585 }
6586 last; };
6587 /^2$/ && do{ if ($ftype == TType::STRING) {
6588 $xfer += $input->readString(\$self->{guid});
6589 } else {
6590 $xfer += $input->skip($ftype);
6591 }
6592 last; };
6593 /^3$/ && do{ if ($ftype == TType::BOOL) {
6594 $xfer += $input->readBool(\$self->{noteOnly});
6595 } else {
6596 $xfer += $input->skip($ftype);
6597 }
6598 last; };
6599 /^4$/ && do{ if ($ftype == TType::BOOL) {
6600 $xfer += $input->readBool(\$self->{tokenizeForIndexing});
6601 } else {
6602 $xfer += $input->skip($ftype);
6603 }
6604 last; };
6605 $xfer += $input->skip($ftype);
6606 }
6607 $xfer += $input->readFieldEnd();
6608 }
6609 $xfer += $input->readStructEnd();
6610 return $xfer;
6611 }
6612  
6613 sub write {
6614 my ($self, $output) = @_;
6615 my $xfer = 0;
6616 $xfer += $output->writeStructBegin('NoteStore_getNoteSearchText_args');
6617 if (defined $self->{authenticationToken}) {
6618 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
6619 $xfer += $output->writeString($self->{authenticationToken});
6620 $xfer += $output->writeFieldEnd();
6621 }
6622 if (defined $self->{guid}) {
6623 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
6624 $xfer += $output->writeString($self->{guid});
6625 $xfer += $output->writeFieldEnd();
6626 }
6627 if (defined $self->{noteOnly}) {
6628 $xfer += $output->writeFieldBegin('noteOnly', TType::BOOL, 3);
6629 $xfer += $output->writeBool($self->{noteOnly});
6630 $xfer += $output->writeFieldEnd();
6631 }
6632 if (defined $self->{tokenizeForIndexing}) {
6633 $xfer += $output->writeFieldBegin('tokenizeForIndexing', TType::BOOL, 4);
6634 $xfer += $output->writeBool($self->{tokenizeForIndexing});
6635 $xfer += $output->writeFieldEnd();
6636 }
6637 $xfer += $output->writeFieldStop();
6638 $xfer += $output->writeStructEnd();
6639 return $xfer;
6640 }
6641  
6642 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result;
6643 use base qw(Class::Accessor);
6644 Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->mk_accessors( qw( success ) );
6645  
6646 sub new {
6647 my $classname = shift;
6648 my $self = {};
6649 my $vals = shift || {};
6650 $self->{success} = undef;
6651 $self->{userException} = undef;
6652 $self->{systemException} = undef;
6653 $self->{notFoundException} = undef;
6654 if (UNIVERSAL::isa($vals,'HASH')) {
6655 if (defined $vals->{success}) {
6656 $self->{success} = $vals->{success};
6657 }
6658 if (defined $vals->{userException}) {
6659 $self->{userException} = $vals->{userException};
6660 }
6661 if (defined $vals->{systemException}) {
6662 $self->{systemException} = $vals->{systemException};
6663 }
6664 if (defined $vals->{notFoundException}) {
6665 $self->{notFoundException} = $vals->{notFoundException};
6666 }
6667 }
6668 return bless ($self, $classname);
6669 }
6670  
6671 sub getName {
6672 return 'NoteStore_getNoteSearchText_result';
6673 }
6674  
6675 sub read {
6676 my ($self, $input) = @_;
6677 my $xfer = 0;
6678 my $fname;
6679 my $ftype = 0;
6680 my $fid = 0;
6681 $xfer += $input->readStructBegin(\$fname);
6682 while (1)
6683 {
6684 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6685 if ($ftype == TType::STOP) {
6686 last;
6687 }
6688 SWITCH: for($fid)
6689 {
6690 /^0$/ && do{ if ($ftype == TType::STRING) {
6691 $xfer += $input->readString(\$self->{success});
6692 } else {
6693 $xfer += $input->skip($ftype);
6694 }
6695 last; };
6696 /^1$/ && do{ if ($ftype == TType::STRUCT) {
6697 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
6698 $xfer += $self->{userException}->read($input);
6699 } else {
6700 $xfer += $input->skip($ftype);
6701 }
6702 last; };
6703 /^2$/ && do{ if ($ftype == TType::STRUCT) {
6704 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
6705 $xfer += $self->{systemException}->read($input);
6706 } else {
6707 $xfer += $input->skip($ftype);
6708 }
6709 last; };
6710 /^3$/ && do{ if ($ftype == TType::STRUCT) {
6711 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
6712 $xfer += $self->{notFoundException}->read($input);
6713 } else {
6714 $xfer += $input->skip($ftype);
6715 }
6716 last; };
6717 $xfer += $input->skip($ftype);
6718 }
6719 $xfer += $input->readFieldEnd();
6720 }
6721 $xfer += $input->readStructEnd();
6722 return $xfer;
6723 }
6724  
6725 sub write {
6726 my ($self, $output) = @_;
6727 my $xfer = 0;
6728 $xfer += $output->writeStructBegin('NoteStore_getNoteSearchText_result');
6729 if (defined $self->{success}) {
6730 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
6731 $xfer += $output->writeString($self->{success});
6732 $xfer += $output->writeFieldEnd();
6733 }
6734 if (defined $self->{userException}) {
6735 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
6736 $xfer += $self->{userException}->write($output);
6737 $xfer += $output->writeFieldEnd();
6738 }
6739 if (defined $self->{systemException}) {
6740 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
6741 $xfer += $self->{systemException}->write($output);
6742 $xfer += $output->writeFieldEnd();
6743 }
6744 if (defined $self->{notFoundException}) {
6745 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
6746 $xfer += $self->{notFoundException}->write($output);
6747 $xfer += $output->writeFieldEnd();
6748 }
6749 $xfer += $output->writeFieldStop();
6750 $xfer += $output->writeStructEnd();
6751 return $xfer;
6752 }
6753  
6754 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args;
6755 use base qw(Class::Accessor);
6756 Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->mk_accessors( qw( authenticationToken guid ) );
6757  
6758 sub new {
6759 my $classname = shift;
6760 my $self = {};
6761 my $vals = shift || {};
6762 $self->{authenticationToken} = undef;
6763 $self->{guid} = undef;
6764 if (UNIVERSAL::isa($vals,'HASH')) {
6765 if (defined $vals->{authenticationToken}) {
6766 $self->{authenticationToken} = $vals->{authenticationToken};
6767 }
6768 if (defined $vals->{guid}) {
6769 $self->{guid} = $vals->{guid};
6770 }
6771 }
6772 return bless ($self, $classname);
6773 }
6774  
6775 sub getName {
6776 return 'NoteStore_getResourceSearchText_args';
6777 }
6778  
6779 sub read {
6780 my ($self, $input) = @_;
6781 my $xfer = 0;
6782 my $fname;
6783 my $ftype = 0;
6784 my $fid = 0;
6785 $xfer += $input->readStructBegin(\$fname);
6786 while (1)
6787 {
6788 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6789 if ($ftype == TType::STOP) {
6790 last;
6791 }
6792 SWITCH: for($fid)
6793 {
6794 /^1$/ && do{ if ($ftype == TType::STRING) {
6795 $xfer += $input->readString(\$self->{authenticationToken});
6796 } else {
6797 $xfer += $input->skip($ftype);
6798 }
6799 last; };
6800 /^2$/ && do{ if ($ftype == TType::STRING) {
6801 $xfer += $input->readString(\$self->{guid});
6802 } else {
6803 $xfer += $input->skip($ftype);
6804 }
6805 last; };
6806 $xfer += $input->skip($ftype);
6807 }
6808 $xfer += $input->readFieldEnd();
6809 }
6810 $xfer += $input->readStructEnd();
6811 return $xfer;
6812 }
6813  
6814 sub write {
6815 my ($self, $output) = @_;
6816 my $xfer = 0;
6817 $xfer += $output->writeStructBegin('NoteStore_getResourceSearchText_args');
6818 if (defined $self->{authenticationToken}) {
6819 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
6820 $xfer += $output->writeString($self->{authenticationToken});
6821 $xfer += $output->writeFieldEnd();
6822 }
6823 if (defined $self->{guid}) {
6824 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
6825 $xfer += $output->writeString($self->{guid});
6826 $xfer += $output->writeFieldEnd();
6827 }
6828 $xfer += $output->writeFieldStop();
6829 $xfer += $output->writeStructEnd();
6830 return $xfer;
6831 }
6832  
6833 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result;
6834 use base qw(Class::Accessor);
6835 Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->mk_accessors( qw( success ) );
6836  
6837 sub new {
6838 my $classname = shift;
6839 my $self = {};
6840 my $vals = shift || {};
6841 $self->{success} = undef;
6842 $self->{userException} = undef;
6843 $self->{systemException} = undef;
6844 $self->{notFoundException} = undef;
6845 if (UNIVERSAL::isa($vals,'HASH')) {
6846 if (defined $vals->{success}) {
6847 $self->{success} = $vals->{success};
6848 }
6849 if (defined $vals->{userException}) {
6850 $self->{userException} = $vals->{userException};
6851 }
6852 if (defined $vals->{systemException}) {
6853 $self->{systemException} = $vals->{systemException};
6854 }
6855 if (defined $vals->{notFoundException}) {
6856 $self->{notFoundException} = $vals->{notFoundException};
6857 }
6858 }
6859 return bless ($self, $classname);
6860 }
6861  
6862 sub getName {
6863 return 'NoteStore_getResourceSearchText_result';
6864 }
6865  
6866 sub read {
6867 my ($self, $input) = @_;
6868 my $xfer = 0;
6869 my $fname;
6870 my $ftype = 0;
6871 my $fid = 0;
6872 $xfer += $input->readStructBegin(\$fname);
6873 while (1)
6874 {
6875 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6876 if ($ftype == TType::STOP) {
6877 last;
6878 }
6879 SWITCH: for($fid)
6880 {
6881 /^0$/ && do{ if ($ftype == TType::STRING) {
6882 $xfer += $input->readString(\$self->{success});
6883 } else {
6884 $xfer += $input->skip($ftype);
6885 }
6886 last; };
6887 /^1$/ && do{ if ($ftype == TType::STRUCT) {
6888 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
6889 $xfer += $self->{userException}->read($input);
6890 } else {
6891 $xfer += $input->skip($ftype);
6892 }
6893 last; };
6894 /^2$/ && do{ if ($ftype == TType::STRUCT) {
6895 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
6896 $xfer += $self->{systemException}->read($input);
6897 } else {
6898 $xfer += $input->skip($ftype);
6899 }
6900 last; };
6901 /^3$/ && do{ if ($ftype == TType::STRUCT) {
6902 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
6903 $xfer += $self->{notFoundException}->read($input);
6904 } else {
6905 $xfer += $input->skip($ftype);
6906 }
6907 last; };
6908 $xfer += $input->skip($ftype);
6909 }
6910 $xfer += $input->readFieldEnd();
6911 }
6912 $xfer += $input->readStructEnd();
6913 return $xfer;
6914 }
6915  
6916 sub write {
6917 my ($self, $output) = @_;
6918 my $xfer = 0;
6919 $xfer += $output->writeStructBegin('NoteStore_getResourceSearchText_result');
6920 if (defined $self->{success}) {
6921 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
6922 $xfer += $output->writeString($self->{success});
6923 $xfer += $output->writeFieldEnd();
6924 }
6925 if (defined $self->{userException}) {
6926 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
6927 $xfer += $self->{userException}->write($output);
6928 $xfer += $output->writeFieldEnd();
6929 }
6930 if (defined $self->{systemException}) {
6931 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
6932 $xfer += $self->{systemException}->write($output);
6933 $xfer += $output->writeFieldEnd();
6934 }
6935 if (defined $self->{notFoundException}) {
6936 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
6937 $xfer += $self->{notFoundException}->write($output);
6938 $xfer += $output->writeFieldEnd();
6939 }
6940 $xfer += $output->writeFieldStop();
6941 $xfer += $output->writeStructEnd();
6942 return $xfer;
6943 }
6944  
6945 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args;
6946 use base qw(Class::Accessor);
6947 Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->mk_accessors( qw( authenticationToken guid ) );
6948  
6949 sub new {
6950 my $classname = shift;
6951 my $self = {};
6952 my $vals = shift || {};
6953 $self->{authenticationToken} = undef;
6954 $self->{guid} = undef;
6955 if (UNIVERSAL::isa($vals,'HASH')) {
6956 if (defined $vals->{authenticationToken}) {
6957 $self->{authenticationToken} = $vals->{authenticationToken};
6958 }
6959 if (defined $vals->{guid}) {
6960 $self->{guid} = $vals->{guid};
6961 }
6962 }
6963 return bless ($self, $classname);
6964 }
6965  
6966 sub getName {
6967 return 'NoteStore_getNoteTagNames_args';
6968 }
6969  
6970 sub read {
6971 my ($self, $input) = @_;
6972 my $xfer = 0;
6973 my $fname;
6974 my $ftype = 0;
6975 my $fid = 0;
6976 $xfer += $input->readStructBegin(\$fname);
6977 while (1)
6978 {
6979 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
6980 if ($ftype == TType::STOP) {
6981 last;
6982 }
6983 SWITCH: for($fid)
6984 {
6985 /^1$/ && do{ if ($ftype == TType::STRING) {
6986 $xfer += $input->readString(\$self->{authenticationToken});
6987 } else {
6988 $xfer += $input->skip($ftype);
6989 }
6990 last; };
6991 /^2$/ && do{ if ($ftype == TType::STRING) {
6992 $xfer += $input->readString(\$self->{guid});
6993 } else {
6994 $xfer += $input->skip($ftype);
6995 }
6996 last; };
6997 $xfer += $input->skip($ftype);
6998 }
6999 $xfer += $input->readFieldEnd();
7000 }
7001 $xfer += $input->readStructEnd();
7002 return $xfer;
7003 }
7004  
7005 sub write {
7006 my ($self, $output) = @_;
7007 my $xfer = 0;
7008 $xfer += $output->writeStructBegin('NoteStore_getNoteTagNames_args');
7009 if (defined $self->{authenticationToken}) {
7010 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
7011 $xfer += $output->writeString($self->{authenticationToken});
7012 $xfer += $output->writeFieldEnd();
7013 }
7014 if (defined $self->{guid}) {
7015 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
7016 $xfer += $output->writeString($self->{guid});
7017 $xfer += $output->writeFieldEnd();
7018 }
7019 $xfer += $output->writeFieldStop();
7020 $xfer += $output->writeStructEnd();
7021 return $xfer;
7022 }
7023  
7024 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result;
7025 use base qw(Class::Accessor);
7026 Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->mk_accessors( qw( success ) );
7027  
7028 sub new {
7029 my $classname = shift;
7030 my $self = {};
7031 my $vals = shift || {};
7032 $self->{success} = undef;
7033 $self->{userException} = undef;
7034 $self->{systemException} = undef;
7035 $self->{notFoundException} = undef;
7036 if (UNIVERSAL::isa($vals,'HASH')) {
7037 if (defined $vals->{success}) {
7038 $self->{success} = $vals->{success};
7039 }
7040 if (defined $vals->{userException}) {
7041 $self->{userException} = $vals->{userException};
7042 }
7043 if (defined $vals->{systemException}) {
7044 $self->{systemException} = $vals->{systemException};
7045 }
7046 if (defined $vals->{notFoundException}) {
7047 $self->{notFoundException} = $vals->{notFoundException};
7048 }
7049 }
7050 return bless ($self, $classname);
7051 }
7052  
7053 sub getName {
7054 return 'NoteStore_getNoteTagNames_result';
7055 }
7056  
7057 sub read {
7058 my ($self, $input) = @_;
7059 my $xfer = 0;
7060 my $fname;
7061 my $ftype = 0;
7062 my $fid = 0;
7063 $xfer += $input->readStructBegin(\$fname);
7064 while (1)
7065 {
7066 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7067 if ($ftype == TType::STOP) {
7068 last;
7069 }
7070 SWITCH: for($fid)
7071 {
7072 /^0$/ && do{ if ($ftype == TType::LIST) {
7073 {
7074 my $_size209 = 0;
7075 $self->{success} = [];
7076 my $_etype212 = 0;
7077 $xfer += $input->readListBegin(\$_etype212, \$_size209);
7078 for (my $_i213 = 0; $_i213 < $_size209; ++$_i213)
7079 {
7080 my $elem214 = undef;
7081 $xfer += $input->readString(\$elem214);
7082 push(@{$self->{success}},$elem214);
7083 }
7084 $xfer += $input->readListEnd();
7085 }
7086 } else {
7087 $xfer += $input->skip($ftype);
7088 }
7089 last; };
7090 /^1$/ && do{ if ($ftype == TType::STRUCT) {
7091 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
7092 $xfer += $self->{userException}->read($input);
7093 } else {
7094 $xfer += $input->skip($ftype);
7095 }
7096 last; };
7097 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7098 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
7099 $xfer += $self->{systemException}->read($input);
7100 } else {
7101 $xfer += $input->skip($ftype);
7102 }
7103 last; };
7104 /^3$/ && do{ if ($ftype == TType::STRUCT) {
7105 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
7106 $xfer += $self->{notFoundException}->read($input);
7107 } else {
7108 $xfer += $input->skip($ftype);
7109 }
7110 last; };
7111 $xfer += $input->skip($ftype);
7112 }
7113 $xfer += $input->readFieldEnd();
7114 }
7115 $xfer += $input->readStructEnd();
7116 return $xfer;
7117 }
7118  
7119 sub write {
7120 my ($self, $output) = @_;
7121 my $xfer = 0;
7122 $xfer += $output->writeStructBegin('NoteStore_getNoteTagNames_result');
7123 if (defined $self->{success}) {
7124 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
7125 {
7126 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
7127 {
7128 foreach my $iter215 (@{$self->{success}})
7129 {
7130 $xfer += $output->writeString($iter215);
7131 }
7132 }
7133 $xfer += $output->writeListEnd();
7134 }
7135 $xfer += $output->writeFieldEnd();
7136 }
7137 if (defined $self->{userException}) {
7138 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
7139 $xfer += $self->{userException}->write($output);
7140 $xfer += $output->writeFieldEnd();
7141 }
7142 if (defined $self->{systemException}) {
7143 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
7144 $xfer += $self->{systemException}->write($output);
7145 $xfer += $output->writeFieldEnd();
7146 }
7147 if (defined $self->{notFoundException}) {
7148 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
7149 $xfer += $self->{notFoundException}->write($output);
7150 $xfer += $output->writeFieldEnd();
7151 }
7152 $xfer += $output->writeFieldStop();
7153 $xfer += $output->writeStructEnd();
7154 return $xfer;
7155 }
7156  
7157 package Net::Evernote::EDAMNoteStore::NoteStore_createNote_args;
7158 use base qw(Class::Accessor);
7159 Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->mk_accessors( qw( authenticationToken note ) );
7160  
7161 sub new {
7162 my $classname = shift;
7163 my $self = {};
7164 my $vals = shift || {};
7165 $self->{authenticationToken} = undef;
7166 $self->{note} = undef;
7167 if (UNIVERSAL::isa($vals,'HASH')) {
7168 if (defined $vals->{authenticationToken}) {
7169 $self->{authenticationToken} = $vals->{authenticationToken};
7170 }
7171 if (defined $vals->{note}) {
7172 $self->{note} = $vals->{note};
7173 }
7174 }
7175 return bless ($self, $classname);
7176 }
7177  
7178 sub getName {
7179 return 'NoteStore_createNote_args';
7180 }
7181  
7182 sub read {
7183 my ($self, $input) = @_;
7184 my $xfer = 0;
7185 my $fname;
7186 my $ftype = 0;
7187 my $fid = 0;
7188 $xfer += $input->readStructBegin(\$fname);
7189 while (1)
7190 {
7191 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7192 if ($ftype == TType::STOP) {
7193 last;
7194 }
7195 SWITCH: for($fid)
7196 {
7197 /^1$/ && do{ if ($ftype == TType::STRING) {
7198 $xfer += $input->readString(\$self->{authenticationToken});
7199 } else {
7200 $xfer += $input->skip($ftype);
7201 }
7202 last; };
7203 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7204 $self->{note} = Net::Evernote::EDAMTypes::Note->new();
7205 $xfer += $self->{note}->read($input);
7206 } else {
7207 $xfer += $input->skip($ftype);
7208 }
7209 last; };
7210 $xfer += $input->skip($ftype);
7211 }
7212 $xfer += $input->readFieldEnd();
7213 }
7214 $xfer += $input->readStructEnd();
7215 return $xfer;
7216 }
7217  
7218 sub write {
7219 my ($self, $output) = @_;
7220 my $xfer = 0;
7221 $xfer += $output->writeStructBegin('NoteStore_createNote_args');
7222 if (defined $self->{authenticationToken}) {
7223 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
7224 $xfer += $output->writeString($self->{authenticationToken});
7225 $xfer += $output->writeFieldEnd();
7226 }
7227 if (defined $self->{note}) {
7228 $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
7229 $xfer += $self->{note}->write($output);
7230 $xfer += $output->writeFieldEnd();
7231 }
7232 $xfer += $output->writeFieldStop();
7233 $xfer += $output->writeStructEnd();
7234 return $xfer;
7235 }
7236  
7237 package Net::Evernote::EDAMNoteStore::NoteStore_createNote_result;
7238 use base qw(Class::Accessor);
7239 Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->mk_accessors( qw( success ) );
7240  
7241 sub new {
7242 my $classname = shift;
7243 my $self = {};
7244 my $vals = shift || {};
7245 $self->{success} = undef;
7246 $self->{userException} = undef;
7247 $self->{systemException} = undef;
7248 $self->{notFoundException} = undef;
7249 if (UNIVERSAL::isa($vals,'HASH')) {
7250 if (defined $vals->{success}) {
7251 $self->{success} = $vals->{success};
7252 }
7253 if (defined $vals->{userException}) {
7254 $self->{userException} = $vals->{userException};
7255 }
7256 if (defined $vals->{systemException}) {
7257 $self->{systemException} = $vals->{systemException};
7258 }
7259 if (defined $vals->{notFoundException}) {
7260 $self->{notFoundException} = $vals->{notFoundException};
7261 }
7262 }
7263 return bless ($self, $classname);
7264 }
7265  
7266 sub getName {
7267 return 'NoteStore_createNote_result';
7268 }
7269  
7270 sub read {
7271 my ($self, $input) = @_;
7272 my $xfer = 0;
7273 my $fname;
7274 my $ftype = 0;
7275 my $fid = 0;
7276 $xfer += $input->readStructBegin(\$fname);
7277 while (1)
7278 {
7279 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7280 if ($ftype == TType::STOP) {
7281 last;
7282 }
7283 SWITCH: for($fid)
7284 {
7285 /^0$/ && do{ if ($ftype == TType::STRUCT) {
7286 $self->{success} = Net::Evernote::EDAMTypes::Note->new();
7287 $xfer += $self->{success}->read($input);
7288 } else {
7289 $xfer += $input->skip($ftype);
7290 }
7291 last; };
7292 /^1$/ && do{ if ($ftype == TType::STRUCT) {
7293 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
7294 $xfer += $self->{userException}->read($input);
7295 } else {
7296 $xfer += $input->skip($ftype);
7297 }
7298 last; };
7299 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7300 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
7301 $xfer += $self->{systemException}->read($input);
7302 } else {
7303 $xfer += $input->skip($ftype);
7304 }
7305 last; };
7306 /^3$/ && do{ if ($ftype == TType::STRUCT) {
7307 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
7308 $xfer += $self->{notFoundException}->read($input);
7309 } else {
7310 $xfer += $input->skip($ftype);
7311 }
7312 last; };
7313 $xfer += $input->skip($ftype);
7314 }
7315 $xfer += $input->readFieldEnd();
7316 }
7317 $xfer += $input->readStructEnd();
7318 return $xfer;
7319 }
7320  
7321 sub write {
7322 my ($self, $output) = @_;
7323 my $xfer = 0;
7324 $xfer += $output->writeStructBegin('NoteStore_createNote_result');
7325 if (defined $self->{success}) {
7326 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
7327 $xfer += $self->{success}->write($output);
7328 $xfer += $output->writeFieldEnd();
7329 }
7330 if (defined $self->{userException}) {
7331 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
7332 $xfer += $self->{userException}->write($output);
7333 $xfer += $output->writeFieldEnd();
7334 }
7335 if (defined $self->{systemException}) {
7336 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
7337 $xfer += $self->{systemException}->write($output);
7338 $xfer += $output->writeFieldEnd();
7339 }
7340 if (defined $self->{notFoundException}) {
7341 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
7342 $xfer += $self->{notFoundException}->write($output);
7343 $xfer += $output->writeFieldEnd();
7344 }
7345 $xfer += $output->writeFieldStop();
7346 $xfer += $output->writeStructEnd();
7347 return $xfer;
7348 }
7349  
7350 package Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args;
7351 use base qw(Class::Accessor);
7352 Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->mk_accessors( qw( authenticationToken note ) );
7353  
7354 sub new {
7355 my $classname = shift;
7356 my $self = {};
7357 my $vals = shift || {};
7358 $self->{authenticationToken} = undef;
7359 $self->{note} = undef;
7360 if (UNIVERSAL::isa($vals,'HASH')) {
7361 if (defined $vals->{authenticationToken}) {
7362 $self->{authenticationToken} = $vals->{authenticationToken};
7363 }
7364 if (defined $vals->{note}) {
7365 $self->{note} = $vals->{note};
7366 }
7367 }
7368 return bless ($self, $classname);
7369 }
7370  
7371 sub getName {
7372 return 'NoteStore_updateNote_args';
7373 }
7374  
7375 sub read {
7376 my ($self, $input) = @_;
7377 my $xfer = 0;
7378 my $fname;
7379 my $ftype = 0;
7380 my $fid = 0;
7381 $xfer += $input->readStructBegin(\$fname);
7382 while (1)
7383 {
7384 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7385 if ($ftype == TType::STOP) {
7386 last;
7387 }
7388 SWITCH: for($fid)
7389 {
7390 /^1$/ && do{ if ($ftype == TType::STRING) {
7391 $xfer += $input->readString(\$self->{authenticationToken});
7392 } else {
7393 $xfer += $input->skip($ftype);
7394 }
7395 last; };
7396 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7397 $self->{note} = Net::Evernote::EDAMTypes::Note->new();
7398 $xfer += $self->{note}->read($input);
7399 } else {
7400 $xfer += $input->skip($ftype);
7401 }
7402 last; };
7403 $xfer += $input->skip($ftype);
7404 }
7405 $xfer += $input->readFieldEnd();
7406 }
7407 $xfer += $input->readStructEnd();
7408 return $xfer;
7409 }
7410  
7411 sub write {
7412 my ($self, $output) = @_;
7413 my $xfer = 0;
7414 $xfer += $output->writeStructBegin('NoteStore_updateNote_args');
7415 if (defined $self->{authenticationToken}) {
7416 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
7417 $xfer += $output->writeString($self->{authenticationToken});
7418 $xfer += $output->writeFieldEnd();
7419 }
7420 if (defined $self->{note}) {
7421 $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
7422 $xfer += $self->{note}->write($output);
7423 $xfer += $output->writeFieldEnd();
7424 }
7425 $xfer += $output->writeFieldStop();
7426 $xfer += $output->writeStructEnd();
7427 return $xfer;
7428 }
7429  
7430 package Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result;
7431 use base qw(Class::Accessor);
7432 Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->mk_accessors( qw( success ) );
7433  
7434 sub new {
7435 my $classname = shift;
7436 my $self = {};
7437 my $vals = shift || {};
7438 $self->{success} = undef;
7439 $self->{userException} = undef;
7440 $self->{systemException} = undef;
7441 $self->{notFoundException} = undef;
7442 if (UNIVERSAL::isa($vals,'HASH')) {
7443 if (defined $vals->{success}) {
7444 $self->{success} = $vals->{success};
7445 }
7446 if (defined $vals->{userException}) {
7447 $self->{userException} = $vals->{userException};
7448 }
7449 if (defined $vals->{systemException}) {
7450 $self->{systemException} = $vals->{systemException};
7451 }
7452 if (defined $vals->{notFoundException}) {
7453 $self->{notFoundException} = $vals->{notFoundException};
7454 }
7455 }
7456 return bless ($self, $classname);
7457 }
7458  
7459 sub getName {
7460 return 'NoteStore_updateNote_result';
7461 }
7462  
7463 sub read {
7464 my ($self, $input) = @_;
7465 my $xfer = 0;
7466 my $fname;
7467 my $ftype = 0;
7468 my $fid = 0;
7469 $xfer += $input->readStructBegin(\$fname);
7470 while (1)
7471 {
7472 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7473 if ($ftype == TType::STOP) {
7474 last;
7475 }
7476 SWITCH: for($fid)
7477 {
7478 /^0$/ && do{ if ($ftype == TType::STRUCT) {
7479 $self->{success} = Net::Evernote::EDAMTypes::Note->new();
7480 $xfer += $self->{success}->read($input);
7481 } else {
7482 $xfer += $input->skip($ftype);
7483 }
7484 last; };
7485 /^1$/ && do{ if ($ftype == TType::STRUCT) {
7486 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
7487 $xfer += $self->{userException}->read($input);
7488 } else {
7489 $xfer += $input->skip($ftype);
7490 }
7491 last; };
7492 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7493 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
7494 $xfer += $self->{systemException}->read($input);
7495 } else {
7496 $xfer += $input->skip($ftype);
7497 }
7498 last; };
7499 /^3$/ && do{ if ($ftype == TType::STRUCT) {
7500 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
7501 $xfer += $self->{notFoundException}->read($input);
7502 } else {
7503 $xfer += $input->skip($ftype);
7504 }
7505 last; };
7506 $xfer += $input->skip($ftype);
7507 }
7508 $xfer += $input->readFieldEnd();
7509 }
7510 $xfer += $input->readStructEnd();
7511 return $xfer;
7512 }
7513  
7514 sub write {
7515 my ($self, $output) = @_;
7516 my $xfer = 0;
7517 $xfer += $output->writeStructBegin('NoteStore_updateNote_result');
7518 if (defined $self->{success}) {
7519 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
7520 $xfer += $self->{success}->write($output);
7521 $xfer += $output->writeFieldEnd();
7522 }
7523 if (defined $self->{userException}) {
7524 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
7525 $xfer += $self->{userException}->write($output);
7526 $xfer += $output->writeFieldEnd();
7527 }
7528 if (defined $self->{systemException}) {
7529 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
7530 $xfer += $self->{systemException}->write($output);
7531 $xfer += $output->writeFieldEnd();
7532 }
7533 if (defined $self->{notFoundException}) {
7534 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
7535 $xfer += $self->{notFoundException}->write($output);
7536 $xfer += $output->writeFieldEnd();
7537 }
7538 $xfer += $output->writeFieldStop();
7539 $xfer += $output->writeStructEnd();
7540 return $xfer;
7541 }
7542  
7543 package Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args;
7544 use base qw(Class::Accessor);
7545 Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->mk_accessors( qw( authenticationToken guid ) );
7546  
7547 sub new {
7548 my $classname = shift;
7549 my $self = {};
7550 my $vals = shift || {};
7551 $self->{authenticationToken} = undef;
7552 $self->{guid} = undef;
7553 if (UNIVERSAL::isa($vals,'HASH')) {
7554 if (defined $vals->{authenticationToken}) {
7555 $self->{authenticationToken} = $vals->{authenticationToken};
7556 }
7557 if (defined $vals->{guid}) {
7558 $self->{guid} = $vals->{guid};
7559 }
7560 }
7561 return bless ($self, $classname);
7562 }
7563  
7564 sub getName {
7565 return 'NoteStore_deleteNote_args';
7566 }
7567  
7568 sub read {
7569 my ($self, $input) = @_;
7570 my $xfer = 0;
7571 my $fname;
7572 my $ftype = 0;
7573 my $fid = 0;
7574 $xfer += $input->readStructBegin(\$fname);
7575 while (1)
7576 {
7577 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7578 if ($ftype == TType::STOP) {
7579 last;
7580 }
7581 SWITCH: for($fid)
7582 {
7583 /^1$/ && do{ if ($ftype == TType::STRING) {
7584 $xfer += $input->readString(\$self->{authenticationToken});
7585 } else {
7586 $xfer += $input->skip($ftype);
7587 }
7588 last; };
7589 /^2$/ && do{ if ($ftype == TType::STRING) {
7590 $xfer += $input->readString(\$self->{guid});
7591 } else {
7592 $xfer += $input->skip($ftype);
7593 }
7594 last; };
7595 $xfer += $input->skip($ftype);
7596 }
7597 $xfer += $input->readFieldEnd();
7598 }
7599 $xfer += $input->readStructEnd();
7600 return $xfer;
7601 }
7602  
7603 sub write {
7604 my ($self, $output) = @_;
7605 my $xfer = 0;
7606 $xfer += $output->writeStructBegin('NoteStore_deleteNote_args');
7607 if (defined $self->{authenticationToken}) {
7608 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
7609 $xfer += $output->writeString($self->{authenticationToken});
7610 $xfer += $output->writeFieldEnd();
7611 }
7612 if (defined $self->{guid}) {
7613 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
7614 $xfer += $output->writeString($self->{guid});
7615 $xfer += $output->writeFieldEnd();
7616 }
7617 $xfer += $output->writeFieldStop();
7618 $xfer += $output->writeStructEnd();
7619 return $xfer;
7620 }
7621  
7622 package Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result;
7623 use base qw(Class::Accessor);
7624 Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->mk_accessors( qw( success ) );
7625  
7626 sub new {
7627 my $classname = shift;
7628 my $self = {};
7629 my $vals = shift || {};
7630 $self->{success} = undef;
7631 $self->{userException} = undef;
7632 $self->{systemException} = undef;
7633 $self->{notFoundException} = undef;
7634 if (UNIVERSAL::isa($vals,'HASH')) {
7635 if (defined $vals->{success}) {
7636 $self->{success} = $vals->{success};
7637 }
7638 if (defined $vals->{userException}) {
7639 $self->{userException} = $vals->{userException};
7640 }
7641 if (defined $vals->{systemException}) {
7642 $self->{systemException} = $vals->{systemException};
7643 }
7644 if (defined $vals->{notFoundException}) {
7645 $self->{notFoundException} = $vals->{notFoundException};
7646 }
7647 }
7648 return bless ($self, $classname);
7649 }
7650  
7651 sub getName {
7652 return 'NoteStore_deleteNote_result';
7653 }
7654  
7655 sub read {
7656 my ($self, $input) = @_;
7657 my $xfer = 0;
7658 my $fname;
7659 my $ftype = 0;
7660 my $fid = 0;
7661 $xfer += $input->readStructBegin(\$fname);
7662 while (1)
7663 {
7664 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7665 if ($ftype == TType::STOP) {
7666 last;
7667 }
7668 SWITCH: for($fid)
7669 {
7670 /^0$/ && do{ if ($ftype == TType::I32) {
7671 $xfer += $input->readI32(\$self->{success});
7672 } else {
7673 $xfer += $input->skip($ftype);
7674 }
7675 last; };
7676 /^1$/ && do{ if ($ftype == TType::STRUCT) {
7677 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
7678 $xfer += $self->{userException}->read($input);
7679 } else {
7680 $xfer += $input->skip($ftype);
7681 }
7682 last; };
7683 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7684 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
7685 $xfer += $self->{systemException}->read($input);
7686 } else {
7687 $xfer += $input->skip($ftype);
7688 }
7689 last; };
7690 /^3$/ && do{ if ($ftype == TType::STRUCT) {
7691 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
7692 $xfer += $self->{notFoundException}->read($input);
7693 } else {
7694 $xfer += $input->skip($ftype);
7695 }
7696 last; };
7697 $xfer += $input->skip($ftype);
7698 }
7699 $xfer += $input->readFieldEnd();
7700 }
7701 $xfer += $input->readStructEnd();
7702 return $xfer;
7703 }
7704  
7705 sub write {
7706 my ($self, $output) = @_;
7707 my $xfer = 0;
7708 $xfer += $output->writeStructBegin('NoteStore_deleteNote_result');
7709 if (defined $self->{success}) {
7710 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
7711 $xfer += $output->writeI32($self->{success});
7712 $xfer += $output->writeFieldEnd();
7713 }
7714 if (defined $self->{userException}) {
7715 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
7716 $xfer += $self->{userException}->write($output);
7717 $xfer += $output->writeFieldEnd();
7718 }
7719 if (defined $self->{systemException}) {
7720 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
7721 $xfer += $self->{systemException}->write($output);
7722 $xfer += $output->writeFieldEnd();
7723 }
7724 if (defined $self->{notFoundException}) {
7725 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
7726 $xfer += $self->{notFoundException}->write($output);
7727 $xfer += $output->writeFieldEnd();
7728 }
7729 $xfer += $output->writeFieldStop();
7730 $xfer += $output->writeStructEnd();
7731 return $xfer;
7732 }
7733  
7734 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args;
7735 use base qw(Class::Accessor);
7736 Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->mk_accessors( qw( authenticationToken guid ) );
7737  
7738 sub new {
7739 my $classname = shift;
7740 my $self = {};
7741 my $vals = shift || {};
7742 $self->{authenticationToken} = undef;
7743 $self->{guid} = undef;
7744 if (UNIVERSAL::isa($vals,'HASH')) {
7745 if (defined $vals->{authenticationToken}) {
7746 $self->{authenticationToken} = $vals->{authenticationToken};
7747 }
7748 if (defined $vals->{guid}) {
7749 $self->{guid} = $vals->{guid};
7750 }
7751 }
7752 return bless ($self, $classname);
7753 }
7754  
7755 sub getName {
7756 return 'NoteStore_expungeNote_args';
7757 }
7758  
7759 sub read {
7760 my ($self, $input) = @_;
7761 my $xfer = 0;
7762 my $fname;
7763 my $ftype = 0;
7764 my $fid = 0;
7765 $xfer += $input->readStructBegin(\$fname);
7766 while (1)
7767 {
7768 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7769 if ($ftype == TType::STOP) {
7770 last;
7771 }
7772 SWITCH: for($fid)
7773 {
7774 /^1$/ && do{ if ($ftype == TType::STRING) {
7775 $xfer += $input->readString(\$self->{authenticationToken});
7776 } else {
7777 $xfer += $input->skip($ftype);
7778 }
7779 last; };
7780 /^2$/ && do{ if ($ftype == TType::STRING) {
7781 $xfer += $input->readString(\$self->{guid});
7782 } else {
7783 $xfer += $input->skip($ftype);
7784 }
7785 last; };
7786 $xfer += $input->skip($ftype);
7787 }
7788 $xfer += $input->readFieldEnd();
7789 }
7790 $xfer += $input->readStructEnd();
7791 return $xfer;
7792 }
7793  
7794 sub write {
7795 my ($self, $output) = @_;
7796 my $xfer = 0;
7797 $xfer += $output->writeStructBegin('NoteStore_expungeNote_args');
7798 if (defined $self->{authenticationToken}) {
7799 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
7800 $xfer += $output->writeString($self->{authenticationToken});
7801 $xfer += $output->writeFieldEnd();
7802 }
7803 if (defined $self->{guid}) {
7804 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
7805 $xfer += $output->writeString($self->{guid});
7806 $xfer += $output->writeFieldEnd();
7807 }
7808 $xfer += $output->writeFieldStop();
7809 $xfer += $output->writeStructEnd();
7810 return $xfer;
7811 }
7812  
7813 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result;
7814 use base qw(Class::Accessor);
7815 Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->mk_accessors( qw( success ) );
7816  
7817 sub new {
7818 my $classname = shift;
7819 my $self = {};
7820 my $vals = shift || {};
7821 $self->{success} = undef;
7822 $self->{userException} = undef;
7823 $self->{systemException} = undef;
7824 $self->{notFoundException} = undef;
7825 if (UNIVERSAL::isa($vals,'HASH')) {
7826 if (defined $vals->{success}) {
7827 $self->{success} = $vals->{success};
7828 }
7829 if (defined $vals->{userException}) {
7830 $self->{userException} = $vals->{userException};
7831 }
7832 if (defined $vals->{systemException}) {
7833 $self->{systemException} = $vals->{systemException};
7834 }
7835 if (defined $vals->{notFoundException}) {
7836 $self->{notFoundException} = $vals->{notFoundException};
7837 }
7838 }
7839 return bless ($self, $classname);
7840 }
7841  
7842 sub getName {
7843 return 'NoteStore_expungeNote_result';
7844 }
7845  
7846 sub read {
7847 my ($self, $input) = @_;
7848 my $xfer = 0;
7849 my $fname;
7850 my $ftype = 0;
7851 my $fid = 0;
7852 $xfer += $input->readStructBegin(\$fname);
7853 while (1)
7854 {
7855 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7856 if ($ftype == TType::STOP) {
7857 last;
7858 }
7859 SWITCH: for($fid)
7860 {
7861 /^0$/ && do{ if ($ftype == TType::I32) {
7862 $xfer += $input->readI32(\$self->{success});
7863 } else {
7864 $xfer += $input->skip($ftype);
7865 }
7866 last; };
7867 /^1$/ && do{ if ($ftype == TType::STRUCT) {
7868 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
7869 $xfer += $self->{userException}->read($input);
7870 } else {
7871 $xfer += $input->skip($ftype);
7872 }
7873 last; };
7874 /^2$/ && do{ if ($ftype == TType::STRUCT) {
7875 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
7876 $xfer += $self->{systemException}->read($input);
7877 } else {
7878 $xfer += $input->skip($ftype);
7879 }
7880 last; };
7881 /^3$/ && do{ if ($ftype == TType::STRUCT) {
7882 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
7883 $xfer += $self->{notFoundException}->read($input);
7884 } else {
7885 $xfer += $input->skip($ftype);
7886 }
7887 last; };
7888 $xfer += $input->skip($ftype);
7889 }
7890 $xfer += $input->readFieldEnd();
7891 }
7892 $xfer += $input->readStructEnd();
7893 return $xfer;
7894 }
7895  
7896 sub write {
7897 my ($self, $output) = @_;
7898 my $xfer = 0;
7899 $xfer += $output->writeStructBegin('NoteStore_expungeNote_result');
7900 if (defined $self->{success}) {
7901 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
7902 $xfer += $output->writeI32($self->{success});
7903 $xfer += $output->writeFieldEnd();
7904 }
7905 if (defined $self->{userException}) {
7906 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
7907 $xfer += $self->{userException}->write($output);
7908 $xfer += $output->writeFieldEnd();
7909 }
7910 if (defined $self->{systemException}) {
7911 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
7912 $xfer += $self->{systemException}->write($output);
7913 $xfer += $output->writeFieldEnd();
7914 }
7915 if (defined $self->{notFoundException}) {
7916 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
7917 $xfer += $self->{notFoundException}->write($output);
7918 $xfer += $output->writeFieldEnd();
7919 }
7920 $xfer += $output->writeFieldStop();
7921 $xfer += $output->writeStructEnd();
7922 return $xfer;
7923 }
7924  
7925 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args;
7926 use base qw(Class::Accessor);
7927 Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->mk_accessors( qw( authenticationToken noteGuids ) );
7928  
7929 sub new {
7930 my $classname = shift;
7931 my $self = {};
7932 my $vals = shift || {};
7933 $self->{authenticationToken} = undef;
7934 $self->{noteGuids} = undef;
7935 if (UNIVERSAL::isa($vals,'HASH')) {
7936 if (defined $vals->{authenticationToken}) {
7937 $self->{authenticationToken} = $vals->{authenticationToken};
7938 }
7939 if (defined $vals->{noteGuids}) {
7940 $self->{noteGuids} = $vals->{noteGuids};
7941 }
7942 }
7943 return bless ($self, $classname);
7944 }
7945  
7946 sub getName {
7947 return 'NoteStore_expungeNotes_args';
7948 }
7949  
7950 sub read {
7951 my ($self, $input) = @_;
7952 my $xfer = 0;
7953 my $fname;
7954 my $ftype = 0;
7955 my $fid = 0;
7956 $xfer += $input->readStructBegin(\$fname);
7957 while (1)
7958 {
7959 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
7960 if ($ftype == TType::STOP) {
7961 last;
7962 }
7963 SWITCH: for($fid)
7964 {
7965 /^1$/ && do{ if ($ftype == TType::STRING) {
7966 $xfer += $input->readString(\$self->{authenticationToken});
7967 } else {
7968 $xfer += $input->skip($ftype);
7969 }
7970 last; };
7971 /^2$/ && do{ if ($ftype == TType::LIST) {
7972 {
7973 my $_size216 = 0;
7974 $self->{noteGuids} = [];
7975 my $_etype219 = 0;
7976 $xfer += $input->readListBegin(\$_etype219, \$_size216);
7977 for (my $_i220 = 0; $_i220 < $_size216; ++$_i220)
7978 {
7979 my $elem221 = undef;
7980 $xfer += $input->readString(\$elem221);
7981 push(@{$self->{noteGuids}},$elem221);
7982 }
7983 $xfer += $input->readListEnd();
7984 }
7985 } else {
7986 $xfer += $input->skip($ftype);
7987 }
7988 last; };
7989 $xfer += $input->skip($ftype);
7990 }
7991 $xfer += $input->readFieldEnd();
7992 }
7993 $xfer += $input->readStructEnd();
7994 return $xfer;
7995 }
7996  
7997 sub write {
7998 my ($self, $output) = @_;
7999 my $xfer = 0;
8000 $xfer += $output->writeStructBegin('NoteStore_expungeNotes_args');
8001 if (defined $self->{authenticationToken}) {
8002 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
8003 $xfer += $output->writeString($self->{authenticationToken});
8004 $xfer += $output->writeFieldEnd();
8005 }
8006 if (defined $self->{noteGuids}) {
8007 $xfer += $output->writeFieldBegin('noteGuids', TType::LIST, 2);
8008 {
8009 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{noteGuids}}));
8010 {
8011 foreach my $iter222 (@{$self->{noteGuids}})
8012 {
8013 $xfer += $output->writeString($iter222);
8014 }
8015 }
8016 $xfer += $output->writeListEnd();
8017 }
8018 $xfer += $output->writeFieldEnd();
8019 }
8020 $xfer += $output->writeFieldStop();
8021 $xfer += $output->writeStructEnd();
8022 return $xfer;
8023 }
8024  
8025 package Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result;
8026 use base qw(Class::Accessor);
8027 Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->mk_accessors( qw( success ) );
8028  
8029 sub new {
8030 my $classname = shift;
8031 my $self = {};
8032 my $vals = shift || {};
8033 $self->{success} = undef;
8034 $self->{userException} = undef;
8035 $self->{systemException} = undef;
8036 $self->{notFoundException} = undef;
8037 if (UNIVERSAL::isa($vals,'HASH')) {
8038 if (defined $vals->{success}) {
8039 $self->{success} = $vals->{success};
8040 }
8041 if (defined $vals->{userException}) {
8042 $self->{userException} = $vals->{userException};
8043 }
8044 if (defined $vals->{systemException}) {
8045 $self->{systemException} = $vals->{systemException};
8046 }
8047 if (defined $vals->{notFoundException}) {
8048 $self->{notFoundException} = $vals->{notFoundException};
8049 }
8050 }
8051 return bless ($self, $classname);
8052 }
8053  
8054 sub getName {
8055 return 'NoteStore_expungeNotes_result';
8056 }
8057  
8058 sub read {
8059 my ($self, $input) = @_;
8060 my $xfer = 0;
8061 my $fname;
8062 my $ftype = 0;
8063 my $fid = 0;
8064 $xfer += $input->readStructBegin(\$fname);
8065 while (1)
8066 {
8067 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8068 if ($ftype == TType::STOP) {
8069 last;
8070 }
8071 SWITCH: for($fid)
8072 {
8073 /^0$/ && do{ if ($ftype == TType::I32) {
8074 $xfer += $input->readI32(\$self->{success});
8075 } else {
8076 $xfer += $input->skip($ftype);
8077 }
8078 last; };
8079 /^1$/ && do{ if ($ftype == TType::STRUCT) {
8080 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
8081 $xfer += $self->{userException}->read($input);
8082 } else {
8083 $xfer += $input->skip($ftype);
8084 }
8085 last; };
8086 /^2$/ && do{ if ($ftype == TType::STRUCT) {
8087 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
8088 $xfer += $self->{systemException}->read($input);
8089 } else {
8090 $xfer += $input->skip($ftype);
8091 }
8092 last; };
8093 /^3$/ && do{ if ($ftype == TType::STRUCT) {
8094 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
8095 $xfer += $self->{notFoundException}->read($input);
8096 } else {
8097 $xfer += $input->skip($ftype);
8098 }
8099 last; };
8100 $xfer += $input->skip($ftype);
8101 }
8102 $xfer += $input->readFieldEnd();
8103 }
8104 $xfer += $input->readStructEnd();
8105 return $xfer;
8106 }
8107  
8108 sub write {
8109 my ($self, $output) = @_;
8110 my $xfer = 0;
8111 $xfer += $output->writeStructBegin('NoteStore_expungeNotes_result');
8112 if (defined $self->{success}) {
8113 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
8114 $xfer += $output->writeI32($self->{success});
8115 $xfer += $output->writeFieldEnd();
8116 }
8117 if (defined $self->{userException}) {
8118 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
8119 $xfer += $self->{userException}->write($output);
8120 $xfer += $output->writeFieldEnd();
8121 }
8122 if (defined $self->{systemException}) {
8123 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
8124 $xfer += $self->{systemException}->write($output);
8125 $xfer += $output->writeFieldEnd();
8126 }
8127 if (defined $self->{notFoundException}) {
8128 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
8129 $xfer += $self->{notFoundException}->write($output);
8130 $xfer += $output->writeFieldEnd();
8131 }
8132 $xfer += $output->writeFieldStop();
8133 $xfer += $output->writeStructEnd();
8134 return $xfer;
8135 }
8136  
8137 package Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args;
8138 use base qw(Class::Accessor);
8139 Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->mk_accessors( qw( authenticationToken ) );
8140  
8141 sub new {
8142 my $classname = shift;
8143 my $self = {};
8144 my $vals = shift || {};
8145 $self->{authenticationToken} = undef;
8146 if (UNIVERSAL::isa($vals,'HASH')) {
8147 if (defined $vals->{authenticationToken}) {
8148 $self->{authenticationToken} = $vals->{authenticationToken};
8149 }
8150 }
8151 return bless ($self, $classname);
8152 }
8153  
8154 sub getName {
8155 return 'NoteStore_expungeInactiveNotes_args';
8156 }
8157  
8158 sub read {
8159 my ($self, $input) = @_;
8160 my $xfer = 0;
8161 my $fname;
8162 my $ftype = 0;
8163 my $fid = 0;
8164 $xfer += $input->readStructBegin(\$fname);
8165 while (1)
8166 {
8167 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8168 if ($ftype == TType::STOP) {
8169 last;
8170 }
8171 SWITCH: for($fid)
8172 {
8173 /^1$/ && do{ if ($ftype == TType::STRING) {
8174 $xfer += $input->readString(\$self->{authenticationToken});
8175 } else {
8176 $xfer += $input->skip($ftype);
8177 }
8178 last; };
8179 $xfer += $input->skip($ftype);
8180 }
8181 $xfer += $input->readFieldEnd();
8182 }
8183 $xfer += $input->readStructEnd();
8184 return $xfer;
8185 }
8186  
8187 sub write {
8188 my ($self, $output) = @_;
8189 my $xfer = 0;
8190 $xfer += $output->writeStructBegin('NoteStore_expungeInactiveNotes_args');
8191 if (defined $self->{authenticationToken}) {
8192 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
8193 $xfer += $output->writeString($self->{authenticationToken});
8194 $xfer += $output->writeFieldEnd();
8195 }
8196 $xfer += $output->writeFieldStop();
8197 $xfer += $output->writeStructEnd();
8198 return $xfer;
8199 }
8200  
8201 package Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result;
8202 use base qw(Class::Accessor);
8203 Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->mk_accessors( qw( success ) );
8204  
8205 sub new {
8206 my $classname = shift;
8207 my $self = {};
8208 my $vals = shift || {};
8209 $self->{success} = undef;
8210 $self->{userException} = undef;
8211 $self->{systemException} = undef;
8212 if (UNIVERSAL::isa($vals,'HASH')) {
8213 if (defined $vals->{success}) {
8214 $self->{success} = $vals->{success};
8215 }
8216 if (defined $vals->{userException}) {
8217 $self->{userException} = $vals->{userException};
8218 }
8219 if (defined $vals->{systemException}) {
8220 $self->{systemException} = $vals->{systemException};
8221 }
8222 }
8223 return bless ($self, $classname);
8224 }
8225  
8226 sub getName {
8227 return 'NoteStore_expungeInactiveNotes_result';
8228 }
8229  
8230 sub read {
8231 my ($self, $input) = @_;
8232 my $xfer = 0;
8233 my $fname;
8234 my $ftype = 0;
8235 my $fid = 0;
8236 $xfer += $input->readStructBegin(\$fname);
8237 while (1)
8238 {
8239 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8240 if ($ftype == TType::STOP) {
8241 last;
8242 }
8243 SWITCH: for($fid)
8244 {
8245 /^0$/ && do{ if ($ftype == TType::I32) {
8246 $xfer += $input->readI32(\$self->{success});
8247 } else {
8248 $xfer += $input->skip($ftype);
8249 }
8250 last; };
8251 /^1$/ && do{ if ($ftype == TType::STRUCT) {
8252 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
8253 $xfer += $self->{userException}->read($input);
8254 } else {
8255 $xfer += $input->skip($ftype);
8256 }
8257 last; };
8258 /^2$/ && do{ if ($ftype == TType::STRUCT) {
8259 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
8260 $xfer += $self->{systemException}->read($input);
8261 } else {
8262 $xfer += $input->skip($ftype);
8263 }
8264 last; };
8265 $xfer += $input->skip($ftype);
8266 }
8267 $xfer += $input->readFieldEnd();
8268 }
8269 $xfer += $input->readStructEnd();
8270 return $xfer;
8271 }
8272  
8273 sub write {
8274 my ($self, $output) = @_;
8275 my $xfer = 0;
8276 $xfer += $output->writeStructBegin('NoteStore_expungeInactiveNotes_result');
8277 if (defined $self->{success}) {
8278 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
8279 $xfer += $output->writeI32($self->{success});
8280 $xfer += $output->writeFieldEnd();
8281 }
8282 if (defined $self->{userException}) {
8283 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
8284 $xfer += $self->{userException}->write($output);
8285 $xfer += $output->writeFieldEnd();
8286 }
8287 if (defined $self->{systemException}) {
8288 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
8289 $xfer += $self->{systemException}->write($output);
8290 $xfer += $output->writeFieldEnd();
8291 }
8292 $xfer += $output->writeFieldStop();
8293 $xfer += $output->writeStructEnd();
8294 return $xfer;
8295 }
8296  
8297 package Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args;
8298 use base qw(Class::Accessor);
8299 Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->mk_accessors( qw( authenticationToken noteGuid toNotebookGuid ) );
8300  
8301 sub new {
8302 my $classname = shift;
8303 my $self = {};
8304 my $vals = shift || {};
8305 $self->{authenticationToken} = undef;
8306 $self->{noteGuid} = undef;
8307 $self->{toNotebookGuid} = undef;
8308 if (UNIVERSAL::isa($vals,'HASH')) {
8309 if (defined $vals->{authenticationToken}) {
8310 $self->{authenticationToken} = $vals->{authenticationToken};
8311 }
8312 if (defined $vals->{noteGuid}) {
8313 $self->{noteGuid} = $vals->{noteGuid};
8314 }
8315 if (defined $vals->{toNotebookGuid}) {
8316 $self->{toNotebookGuid} = $vals->{toNotebookGuid};
8317 }
8318 }
8319 return bless ($self, $classname);
8320 }
8321  
8322 sub getName {
8323 return 'NoteStore_copyNote_args';
8324 }
8325  
8326 sub read {
8327 my ($self, $input) = @_;
8328 my $xfer = 0;
8329 my $fname;
8330 my $ftype = 0;
8331 my $fid = 0;
8332 $xfer += $input->readStructBegin(\$fname);
8333 while (1)
8334 {
8335 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8336 if ($ftype == TType::STOP) {
8337 last;
8338 }
8339 SWITCH: for($fid)
8340 {
8341 /^1$/ && do{ if ($ftype == TType::STRING) {
8342 $xfer += $input->readString(\$self->{authenticationToken});
8343 } else {
8344 $xfer += $input->skip($ftype);
8345 }
8346 last; };
8347 /^2$/ && do{ if ($ftype == TType::STRING) {
8348 $xfer += $input->readString(\$self->{noteGuid});
8349 } else {
8350 $xfer += $input->skip($ftype);
8351 }
8352 last; };
8353 /^3$/ && do{ if ($ftype == TType::STRING) {
8354 $xfer += $input->readString(\$self->{toNotebookGuid});
8355 } else {
8356 $xfer += $input->skip($ftype);
8357 }
8358 last; };
8359 $xfer += $input->skip($ftype);
8360 }
8361 $xfer += $input->readFieldEnd();
8362 }
8363 $xfer += $input->readStructEnd();
8364 return $xfer;
8365 }
8366  
8367 sub write {
8368 my ($self, $output) = @_;
8369 my $xfer = 0;
8370 $xfer += $output->writeStructBegin('NoteStore_copyNote_args');
8371 if (defined $self->{authenticationToken}) {
8372 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
8373 $xfer += $output->writeString($self->{authenticationToken});
8374 $xfer += $output->writeFieldEnd();
8375 }
8376 if (defined $self->{noteGuid}) {
8377 $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
8378 $xfer += $output->writeString($self->{noteGuid});
8379 $xfer += $output->writeFieldEnd();
8380 }
8381 if (defined $self->{toNotebookGuid}) {
8382 $xfer += $output->writeFieldBegin('toNotebookGuid', TType::STRING, 3);
8383 $xfer += $output->writeString($self->{toNotebookGuid});
8384 $xfer += $output->writeFieldEnd();
8385 }
8386 $xfer += $output->writeFieldStop();
8387 $xfer += $output->writeStructEnd();
8388 return $xfer;
8389 }
8390  
8391 package Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result;
8392 use base qw(Class::Accessor);
8393 Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->mk_accessors( qw( success ) );
8394  
8395 sub new {
8396 my $classname = shift;
8397 my $self = {};
8398 my $vals = shift || {};
8399 $self->{success} = undef;
8400 $self->{userException} = undef;
8401 $self->{systemException} = undef;
8402 $self->{notFoundException} = undef;
8403 if (UNIVERSAL::isa($vals,'HASH')) {
8404 if (defined $vals->{success}) {
8405 $self->{success} = $vals->{success};
8406 }
8407 if (defined $vals->{userException}) {
8408 $self->{userException} = $vals->{userException};
8409 }
8410 if (defined $vals->{systemException}) {
8411 $self->{systemException} = $vals->{systemException};
8412 }
8413 if (defined $vals->{notFoundException}) {
8414 $self->{notFoundException} = $vals->{notFoundException};
8415 }
8416 }
8417 return bless ($self, $classname);
8418 }
8419  
8420 sub getName {
8421 return 'NoteStore_copyNote_result';
8422 }
8423  
8424 sub read {
8425 my ($self, $input) = @_;
8426 my $xfer = 0;
8427 my $fname;
8428 my $ftype = 0;
8429 my $fid = 0;
8430 $xfer += $input->readStructBegin(\$fname);
8431 while (1)
8432 {
8433 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8434 if ($ftype == TType::STOP) {
8435 last;
8436 }
8437 SWITCH: for($fid)
8438 {
8439 /^0$/ && do{ if ($ftype == TType::STRUCT) {
8440 $self->{success} = Net::Evernote::EDAMTypes::Note->new();
8441 $xfer += $self->{success}->read($input);
8442 } else {
8443 $xfer += $input->skip($ftype);
8444 }
8445 last; };
8446 /^1$/ && do{ if ($ftype == TType::STRUCT) {
8447 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
8448 $xfer += $self->{userException}->read($input);
8449 } else {
8450 $xfer += $input->skip($ftype);
8451 }
8452 last; };
8453 /^2$/ && do{ if ($ftype == TType::STRUCT) {
8454 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
8455 $xfer += $self->{systemException}->read($input);
8456 } else {
8457 $xfer += $input->skip($ftype);
8458 }
8459 last; };
8460 /^3$/ && do{ if ($ftype == TType::STRUCT) {
8461 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
8462 $xfer += $self->{notFoundException}->read($input);
8463 } else {
8464 $xfer += $input->skip($ftype);
8465 }
8466 last; };
8467 $xfer += $input->skip($ftype);
8468 }
8469 $xfer += $input->readFieldEnd();
8470 }
8471 $xfer += $input->readStructEnd();
8472 return $xfer;
8473 }
8474  
8475 sub write {
8476 my ($self, $output) = @_;
8477 my $xfer = 0;
8478 $xfer += $output->writeStructBegin('NoteStore_copyNote_result');
8479 if (defined $self->{success}) {
8480 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
8481 $xfer += $self->{success}->write($output);
8482 $xfer += $output->writeFieldEnd();
8483 }
8484 if (defined $self->{userException}) {
8485 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
8486 $xfer += $self->{userException}->write($output);
8487 $xfer += $output->writeFieldEnd();
8488 }
8489 if (defined $self->{systemException}) {
8490 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
8491 $xfer += $self->{systemException}->write($output);
8492 $xfer += $output->writeFieldEnd();
8493 }
8494 if (defined $self->{notFoundException}) {
8495 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
8496 $xfer += $self->{notFoundException}->write($output);
8497 $xfer += $output->writeFieldEnd();
8498 }
8499 $xfer += $output->writeFieldStop();
8500 $xfer += $output->writeStructEnd();
8501 return $xfer;
8502 }
8503  
8504 package Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args;
8505 use base qw(Class::Accessor);
8506 Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->mk_accessors( qw( authenticationToken noteGuid ) );
8507  
8508 sub new {
8509 my $classname = shift;
8510 my $self = {};
8511 my $vals = shift || {};
8512 $self->{authenticationToken} = undef;
8513 $self->{noteGuid} = undef;
8514 if (UNIVERSAL::isa($vals,'HASH')) {
8515 if (defined $vals->{authenticationToken}) {
8516 $self->{authenticationToken} = $vals->{authenticationToken};
8517 }
8518 if (defined $vals->{noteGuid}) {
8519 $self->{noteGuid} = $vals->{noteGuid};
8520 }
8521 }
8522 return bless ($self, $classname);
8523 }
8524  
8525 sub getName {
8526 return 'NoteStore_listNoteVersions_args';
8527 }
8528  
8529 sub read {
8530 my ($self, $input) = @_;
8531 my $xfer = 0;
8532 my $fname;
8533 my $ftype = 0;
8534 my $fid = 0;
8535 $xfer += $input->readStructBegin(\$fname);
8536 while (1)
8537 {
8538 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8539 if ($ftype == TType::STOP) {
8540 last;
8541 }
8542 SWITCH: for($fid)
8543 {
8544 /^1$/ && do{ if ($ftype == TType::STRING) {
8545 $xfer += $input->readString(\$self->{authenticationToken});
8546 } else {
8547 $xfer += $input->skip($ftype);
8548 }
8549 last; };
8550 /^2$/ && do{ if ($ftype == TType::STRING) {
8551 $xfer += $input->readString(\$self->{noteGuid});
8552 } else {
8553 $xfer += $input->skip($ftype);
8554 }
8555 last; };
8556 $xfer += $input->skip($ftype);
8557 }
8558 $xfer += $input->readFieldEnd();
8559 }
8560 $xfer += $input->readStructEnd();
8561 return $xfer;
8562 }
8563  
8564 sub write {
8565 my ($self, $output) = @_;
8566 my $xfer = 0;
8567 $xfer += $output->writeStructBegin('NoteStore_listNoteVersions_args');
8568 if (defined $self->{authenticationToken}) {
8569 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
8570 $xfer += $output->writeString($self->{authenticationToken});
8571 $xfer += $output->writeFieldEnd();
8572 }
8573 if (defined $self->{noteGuid}) {
8574 $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
8575 $xfer += $output->writeString($self->{noteGuid});
8576 $xfer += $output->writeFieldEnd();
8577 }
8578 $xfer += $output->writeFieldStop();
8579 $xfer += $output->writeStructEnd();
8580 return $xfer;
8581 }
8582  
8583 package Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result;
8584 use base qw(Class::Accessor);
8585 Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->mk_accessors( qw( success ) );
8586  
8587 sub new {
8588 my $classname = shift;
8589 my $self = {};
8590 my $vals = shift || {};
8591 $self->{success} = undef;
8592 $self->{userException} = undef;
8593 $self->{systemException} = undef;
8594 $self->{notFoundException} = undef;
8595 if (UNIVERSAL::isa($vals,'HASH')) {
8596 if (defined $vals->{success}) {
8597 $self->{success} = $vals->{success};
8598 }
8599 if (defined $vals->{userException}) {
8600 $self->{userException} = $vals->{userException};
8601 }
8602 if (defined $vals->{systemException}) {
8603 $self->{systemException} = $vals->{systemException};
8604 }
8605 if (defined $vals->{notFoundException}) {
8606 $self->{notFoundException} = $vals->{notFoundException};
8607 }
8608 }
8609 return bless ($self, $classname);
8610 }
8611  
8612 sub getName {
8613 return 'NoteStore_listNoteVersions_result';
8614 }
8615  
8616 sub read {
8617 my ($self, $input) = @_;
8618 my $xfer = 0;
8619 my $fname;
8620 my $ftype = 0;
8621 my $fid = 0;
8622 $xfer += $input->readStructBegin(\$fname);
8623 while (1)
8624 {
8625 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8626 if ($ftype == TType::STOP) {
8627 last;
8628 }
8629 SWITCH: for($fid)
8630 {
8631 /^0$/ && do{ if ($ftype == TType::LIST) {
8632 {
8633 my $_size223 = 0;
8634 $self->{success} = [];
8635 my $_etype226 = 0;
8636 $xfer += $input->readListBegin(\$_etype226, \$_size223);
8637 for (my $_i227 = 0; $_i227 < $_size223; ++$_i227)
8638 {
8639 my $elem228 = undef;
8640 $elem228 = Net::Evernote::EDAMNoteStore::NoteVersionId->new();
8641 $xfer += $elem228->read($input);
8642 push(@{$self->{success}},$elem228);
8643 }
8644 $xfer += $input->readListEnd();
8645 }
8646 } else {
8647 $xfer += $input->skip($ftype);
8648 }
8649 last; };
8650 /^1$/ && do{ if ($ftype == TType::STRUCT) {
8651 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
8652 $xfer += $self->{userException}->read($input);
8653 } else {
8654 $xfer += $input->skip($ftype);
8655 }
8656 last; };
8657 /^2$/ && do{ if ($ftype == TType::STRUCT) {
8658 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
8659 $xfer += $self->{systemException}->read($input);
8660 } else {
8661 $xfer += $input->skip($ftype);
8662 }
8663 last; };
8664 /^3$/ && do{ if ($ftype == TType::STRUCT) {
8665 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
8666 $xfer += $self->{notFoundException}->read($input);
8667 } else {
8668 $xfer += $input->skip($ftype);
8669 }
8670 last; };
8671 $xfer += $input->skip($ftype);
8672 }
8673 $xfer += $input->readFieldEnd();
8674 }
8675 $xfer += $input->readStructEnd();
8676 return $xfer;
8677 }
8678  
8679 sub write {
8680 my ($self, $output) = @_;
8681 my $xfer = 0;
8682 $xfer += $output->writeStructBegin('NoteStore_listNoteVersions_result');
8683 if (defined $self->{success}) {
8684 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
8685 {
8686 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
8687 {
8688 foreach my $iter229 (@{$self->{success}})
8689 {
8690 $xfer += ${iter229}->write($output);
8691 }
8692 }
8693 $xfer += $output->writeListEnd();
8694 }
8695 $xfer += $output->writeFieldEnd();
8696 }
8697 if (defined $self->{userException}) {
8698 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
8699 $xfer += $self->{userException}->write($output);
8700 $xfer += $output->writeFieldEnd();
8701 }
8702 if (defined $self->{systemException}) {
8703 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
8704 $xfer += $self->{systemException}->write($output);
8705 $xfer += $output->writeFieldEnd();
8706 }
8707 if (defined $self->{notFoundException}) {
8708 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
8709 $xfer += $self->{notFoundException}->write($output);
8710 $xfer += $output->writeFieldEnd();
8711 }
8712 $xfer += $output->writeFieldStop();
8713 $xfer += $output->writeStructEnd();
8714 return $xfer;
8715 }
8716  
8717 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args;
8718 use base qw(Class::Accessor);
8719 Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->mk_accessors( qw( authenticationToken noteGuid updateSequenceNum withResourcesData withResourcesRecognition withResourcesAlternateData ) );
8720  
8721 sub new {
8722 my $classname = shift;
8723 my $self = {};
8724 my $vals = shift || {};
8725 $self->{authenticationToken} = undef;
8726 $self->{noteGuid} = undef;
8727 $self->{updateSequenceNum} = undef;
8728 $self->{withResourcesData} = undef;
8729 $self->{withResourcesRecognition} = undef;
8730 $self->{withResourcesAlternateData} = undef;
8731 if (UNIVERSAL::isa($vals,'HASH')) {
8732 if (defined $vals->{authenticationToken}) {
8733 $self->{authenticationToken} = $vals->{authenticationToken};
8734 }
8735 if (defined $vals->{noteGuid}) {
8736 $self->{noteGuid} = $vals->{noteGuid};
8737 }
8738 if (defined $vals->{updateSequenceNum}) {
8739 $self->{updateSequenceNum} = $vals->{updateSequenceNum};
8740 }
8741 if (defined $vals->{withResourcesData}) {
8742 $self->{withResourcesData} = $vals->{withResourcesData};
8743 }
8744 if (defined $vals->{withResourcesRecognition}) {
8745 $self->{withResourcesRecognition} = $vals->{withResourcesRecognition};
8746 }
8747 if (defined $vals->{withResourcesAlternateData}) {
8748 $self->{withResourcesAlternateData} = $vals->{withResourcesAlternateData};
8749 }
8750 }
8751 return bless ($self, $classname);
8752 }
8753  
8754 sub getName {
8755 return 'NoteStore_getNoteVersion_args';
8756 }
8757  
8758 sub read {
8759 my ($self, $input) = @_;
8760 my $xfer = 0;
8761 my $fname;
8762 my $ftype = 0;
8763 my $fid = 0;
8764 $xfer += $input->readStructBegin(\$fname);
8765 while (1)
8766 {
8767 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8768 if ($ftype == TType::STOP) {
8769 last;
8770 }
8771 SWITCH: for($fid)
8772 {
8773 /^1$/ && do{ if ($ftype == TType::STRING) {
8774 $xfer += $input->readString(\$self->{authenticationToken});
8775 } else {
8776 $xfer += $input->skip($ftype);
8777 }
8778 last; };
8779 /^2$/ && do{ if ($ftype == TType::STRING) {
8780 $xfer += $input->readString(\$self->{noteGuid});
8781 } else {
8782 $xfer += $input->skip($ftype);
8783 }
8784 last; };
8785 /^3$/ && do{ if ($ftype == TType::I32) {
8786 $xfer += $input->readI32(\$self->{updateSequenceNum});
8787 } else {
8788 $xfer += $input->skip($ftype);
8789 }
8790 last; };
8791 /^4$/ && do{ if ($ftype == TType::BOOL) {
8792 $xfer += $input->readBool(\$self->{withResourcesData});
8793 } else {
8794 $xfer += $input->skip($ftype);
8795 }
8796 last; };
8797 /^5$/ && do{ if ($ftype == TType::BOOL) {
8798 $xfer += $input->readBool(\$self->{withResourcesRecognition});
8799 } else {
8800 $xfer += $input->skip($ftype);
8801 }
8802 last; };
8803 /^6$/ && do{ if ($ftype == TType::BOOL) {
8804 $xfer += $input->readBool(\$self->{withResourcesAlternateData});
8805 } else {
8806 $xfer += $input->skip($ftype);
8807 }
8808 last; };
8809 $xfer += $input->skip($ftype);
8810 }
8811 $xfer += $input->readFieldEnd();
8812 }
8813 $xfer += $input->readStructEnd();
8814 return $xfer;
8815 }
8816  
8817 sub write {
8818 my ($self, $output) = @_;
8819 my $xfer = 0;
8820 $xfer += $output->writeStructBegin('NoteStore_getNoteVersion_args');
8821 if (defined $self->{authenticationToken}) {
8822 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
8823 $xfer += $output->writeString($self->{authenticationToken});
8824 $xfer += $output->writeFieldEnd();
8825 }
8826 if (defined $self->{noteGuid}) {
8827 $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
8828 $xfer += $output->writeString($self->{noteGuid});
8829 $xfer += $output->writeFieldEnd();
8830 }
8831 if (defined $self->{updateSequenceNum}) {
8832 $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 3);
8833 $xfer += $output->writeI32($self->{updateSequenceNum});
8834 $xfer += $output->writeFieldEnd();
8835 }
8836 if (defined $self->{withResourcesData}) {
8837 $xfer += $output->writeFieldBegin('withResourcesData', TType::BOOL, 4);
8838 $xfer += $output->writeBool($self->{withResourcesData});
8839 $xfer += $output->writeFieldEnd();
8840 }
8841 if (defined $self->{withResourcesRecognition}) {
8842 $xfer += $output->writeFieldBegin('withResourcesRecognition', TType::BOOL, 5);
8843 $xfer += $output->writeBool($self->{withResourcesRecognition});
8844 $xfer += $output->writeFieldEnd();
8845 }
8846 if (defined $self->{withResourcesAlternateData}) {
8847 $xfer += $output->writeFieldBegin('withResourcesAlternateData', TType::BOOL, 6);
8848 $xfer += $output->writeBool($self->{withResourcesAlternateData});
8849 $xfer += $output->writeFieldEnd();
8850 }
8851 $xfer += $output->writeFieldStop();
8852 $xfer += $output->writeStructEnd();
8853 return $xfer;
8854 }
8855  
8856 package Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result;
8857 use base qw(Class::Accessor);
8858 Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->mk_accessors( qw( success ) );
8859  
8860 sub new {
8861 my $classname = shift;
8862 my $self = {};
8863 my $vals = shift || {};
8864 $self->{success} = undef;
8865 $self->{userException} = undef;
8866 $self->{systemException} = undef;
8867 $self->{notFoundException} = undef;
8868 if (UNIVERSAL::isa($vals,'HASH')) {
8869 if (defined $vals->{success}) {
8870 $self->{success} = $vals->{success};
8871 }
8872 if (defined $vals->{userException}) {
8873 $self->{userException} = $vals->{userException};
8874 }
8875 if (defined $vals->{systemException}) {
8876 $self->{systemException} = $vals->{systemException};
8877 }
8878 if (defined $vals->{notFoundException}) {
8879 $self->{notFoundException} = $vals->{notFoundException};
8880 }
8881 }
8882 return bless ($self, $classname);
8883 }
8884  
8885 sub getName {
8886 return 'NoteStore_getNoteVersion_result';
8887 }
8888  
8889 sub read {
8890 my ($self, $input) = @_;
8891 my $xfer = 0;
8892 my $fname;
8893 my $ftype = 0;
8894 my $fid = 0;
8895 $xfer += $input->readStructBegin(\$fname);
8896 while (1)
8897 {
8898 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
8899 if ($ftype == TType::STOP) {
8900 last;
8901 }
8902 SWITCH: for($fid)
8903 {
8904 /^0$/ && do{ if ($ftype == TType::STRUCT) {
8905 $self->{success} = Net::Evernote::EDAMTypes::Note->new();
8906 $xfer += $self->{success}->read($input);
8907 } else {
8908 $xfer += $input->skip($ftype);
8909 }
8910 last; };
8911 /^1$/ && do{ if ($ftype == TType::STRUCT) {
8912 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
8913 $xfer += $self->{userException}->read($input);
8914 } else {
8915 $xfer += $input->skip($ftype);
8916 }
8917 last; };
8918 /^2$/ && do{ if ($ftype == TType::STRUCT) {
8919 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
8920 $xfer += $self->{systemException}->read($input);
8921 } else {
8922 $xfer += $input->skip($ftype);
8923 }
8924 last; };
8925 /^3$/ && do{ if ($ftype == TType::STRUCT) {
8926 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
8927 $xfer += $self->{notFoundException}->read($input);
8928 } else {
8929 $xfer += $input->skip($ftype);
8930 }
8931 last; };
8932 $xfer += $input->skip($ftype);
8933 }
8934 $xfer += $input->readFieldEnd();
8935 }
8936 $xfer += $input->readStructEnd();
8937 return $xfer;
8938 }
8939  
8940 sub write {
8941 my ($self, $output) = @_;
8942 my $xfer = 0;
8943 $xfer += $output->writeStructBegin('NoteStore_getNoteVersion_result');
8944 if (defined $self->{success}) {
8945 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
8946 $xfer += $self->{success}->write($output);
8947 $xfer += $output->writeFieldEnd();
8948 }
8949 if (defined $self->{userException}) {
8950 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
8951 $xfer += $self->{userException}->write($output);
8952 $xfer += $output->writeFieldEnd();
8953 }
8954 if (defined $self->{systemException}) {
8955 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
8956 $xfer += $self->{systemException}->write($output);
8957 $xfer += $output->writeFieldEnd();
8958 }
8959 if (defined $self->{notFoundException}) {
8960 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
8961 $xfer += $self->{notFoundException}->write($output);
8962 $xfer += $output->writeFieldEnd();
8963 }
8964 $xfer += $output->writeFieldStop();
8965 $xfer += $output->writeStructEnd();
8966 return $xfer;
8967 }
8968  
8969 package Net::Evernote::EDAMNoteStore::NoteStore_getResource_args;
8970 use base qw(Class::Accessor);
8971 Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->mk_accessors( qw( authenticationToken guid withData withRecognition withAttributes withAlternateData ) );
8972  
8973 sub new {
8974 my $classname = shift;
8975 my $self = {};
8976 my $vals = shift || {};
8977 $self->{authenticationToken} = undef;
8978 $self->{guid} = undef;
8979 $self->{withData} = undef;
8980 $self->{withRecognition} = undef;
8981 $self->{withAttributes} = undef;
8982 $self->{withAlternateData} = undef;
8983 if (UNIVERSAL::isa($vals,'HASH')) {
8984 if (defined $vals->{authenticationToken}) {
8985 $self->{authenticationToken} = $vals->{authenticationToken};
8986 }
8987 if (defined $vals->{guid}) {
8988 $self->{guid} = $vals->{guid};
8989 }
8990 if (defined $vals->{withData}) {
8991 $self->{withData} = $vals->{withData};
8992 }
8993 if (defined $vals->{withRecognition}) {
8994 $self->{withRecognition} = $vals->{withRecognition};
8995 }
8996 if (defined $vals->{withAttributes}) {
8997 $self->{withAttributes} = $vals->{withAttributes};
8998 }
8999 if (defined $vals->{withAlternateData}) {
9000 $self->{withAlternateData} = $vals->{withAlternateData};
9001 }
9002 }
9003 return bless ($self, $classname);
9004 }
9005  
9006 sub getName {
9007 return 'NoteStore_getResource_args';
9008 }
9009  
9010 sub read {
9011 my ($self, $input) = @_;
9012 my $xfer = 0;
9013 my $fname;
9014 my $ftype = 0;
9015 my $fid = 0;
9016 $xfer += $input->readStructBegin(\$fname);
9017 while (1)
9018 {
9019 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9020 if ($ftype == TType::STOP) {
9021 last;
9022 }
9023 SWITCH: for($fid)
9024 {
9025 /^1$/ && do{ if ($ftype == TType::STRING) {
9026 $xfer += $input->readString(\$self->{authenticationToken});
9027 } else {
9028 $xfer += $input->skip($ftype);
9029 }
9030 last; };
9031 /^2$/ && do{ if ($ftype == TType::STRING) {
9032 $xfer += $input->readString(\$self->{guid});
9033 } else {
9034 $xfer += $input->skip($ftype);
9035 }
9036 last; };
9037 /^3$/ && do{ if ($ftype == TType::BOOL) {
9038 $xfer += $input->readBool(\$self->{withData});
9039 } else {
9040 $xfer += $input->skip($ftype);
9041 }
9042 last; };
9043 /^4$/ && do{ if ($ftype == TType::BOOL) {
9044 $xfer += $input->readBool(\$self->{withRecognition});
9045 } else {
9046 $xfer += $input->skip($ftype);
9047 }
9048 last; };
9049 /^5$/ && do{ if ($ftype == TType::BOOL) {
9050 $xfer += $input->readBool(\$self->{withAttributes});
9051 } else {
9052 $xfer += $input->skip($ftype);
9053 }
9054 last; };
9055 /^6$/ && do{ if ($ftype == TType::BOOL) {
9056 $xfer += $input->readBool(\$self->{withAlternateData});
9057 } else {
9058 $xfer += $input->skip($ftype);
9059 }
9060 last; };
9061 $xfer += $input->skip($ftype);
9062 }
9063 $xfer += $input->readFieldEnd();
9064 }
9065 $xfer += $input->readStructEnd();
9066 return $xfer;
9067 }
9068  
9069 sub write {
9070 my ($self, $output) = @_;
9071 my $xfer = 0;
9072 $xfer += $output->writeStructBegin('NoteStore_getResource_args');
9073 if (defined $self->{authenticationToken}) {
9074 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
9075 $xfer += $output->writeString($self->{authenticationToken});
9076 $xfer += $output->writeFieldEnd();
9077 }
9078 if (defined $self->{guid}) {
9079 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
9080 $xfer += $output->writeString($self->{guid});
9081 $xfer += $output->writeFieldEnd();
9082 }
9083 if (defined $self->{withData}) {
9084 $xfer += $output->writeFieldBegin('withData', TType::BOOL, 3);
9085 $xfer += $output->writeBool($self->{withData});
9086 $xfer += $output->writeFieldEnd();
9087 }
9088 if (defined $self->{withRecognition}) {
9089 $xfer += $output->writeFieldBegin('withRecognition', TType::BOOL, 4);
9090 $xfer += $output->writeBool($self->{withRecognition});
9091 $xfer += $output->writeFieldEnd();
9092 }
9093 if (defined $self->{withAttributes}) {
9094 $xfer += $output->writeFieldBegin('withAttributes', TType::BOOL, 5);
9095 $xfer += $output->writeBool($self->{withAttributes});
9096 $xfer += $output->writeFieldEnd();
9097 }
9098 if (defined $self->{withAlternateData}) {
9099 $xfer += $output->writeFieldBegin('withAlternateData', TType::BOOL, 6);
9100 $xfer += $output->writeBool($self->{withAlternateData});
9101 $xfer += $output->writeFieldEnd();
9102 }
9103 $xfer += $output->writeFieldStop();
9104 $xfer += $output->writeStructEnd();
9105 return $xfer;
9106 }
9107  
9108 package Net::Evernote::EDAMNoteStore::NoteStore_getResource_result;
9109 use base qw(Class::Accessor);
9110 Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->mk_accessors( qw( success ) );
9111  
9112 sub new {
9113 my $classname = shift;
9114 my $self = {};
9115 my $vals = shift || {};
9116 $self->{success} = undef;
9117 $self->{userException} = undef;
9118 $self->{systemException} = undef;
9119 $self->{notFoundException} = undef;
9120 if (UNIVERSAL::isa($vals,'HASH')) {
9121 if (defined $vals->{success}) {
9122 $self->{success} = $vals->{success};
9123 }
9124 if (defined $vals->{userException}) {
9125 $self->{userException} = $vals->{userException};
9126 }
9127 if (defined $vals->{systemException}) {
9128 $self->{systemException} = $vals->{systemException};
9129 }
9130 if (defined $vals->{notFoundException}) {
9131 $self->{notFoundException} = $vals->{notFoundException};
9132 }
9133 }
9134 return bless ($self, $classname);
9135 }
9136  
9137 sub getName {
9138 return 'NoteStore_getResource_result';
9139 }
9140  
9141 sub read {
9142 my ($self, $input) = @_;
9143 my $xfer = 0;
9144 my $fname;
9145 my $ftype = 0;
9146 my $fid = 0;
9147 $xfer += $input->readStructBegin(\$fname);
9148 while (1)
9149 {
9150 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9151 if ($ftype == TType::STOP) {
9152 last;
9153 }
9154 SWITCH: for($fid)
9155 {
9156 /^0$/ && do{ if ($ftype == TType::STRUCT) {
9157 $self->{success} = Net::Evernote::EDAMTypes::Resource->new();
9158 $xfer += $self->{success}->read($input);
9159 } else {
9160 $xfer += $input->skip($ftype);
9161 }
9162 last; };
9163 /^1$/ && do{ if ($ftype == TType::STRUCT) {
9164 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
9165 $xfer += $self->{userException}->read($input);
9166 } else {
9167 $xfer += $input->skip($ftype);
9168 }
9169 last; };
9170 /^2$/ && do{ if ($ftype == TType::STRUCT) {
9171 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
9172 $xfer += $self->{systemException}->read($input);
9173 } else {
9174 $xfer += $input->skip($ftype);
9175 }
9176 last; };
9177 /^3$/ && do{ if ($ftype == TType::STRUCT) {
9178 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
9179 $xfer += $self->{notFoundException}->read($input);
9180 } else {
9181 $xfer += $input->skip($ftype);
9182 }
9183 last; };
9184 $xfer += $input->skip($ftype);
9185 }
9186 $xfer += $input->readFieldEnd();
9187 }
9188 $xfer += $input->readStructEnd();
9189 return $xfer;
9190 }
9191  
9192 sub write {
9193 my ($self, $output) = @_;
9194 my $xfer = 0;
9195 $xfer += $output->writeStructBegin('NoteStore_getResource_result');
9196 if (defined $self->{success}) {
9197 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
9198 $xfer += $self->{success}->write($output);
9199 $xfer += $output->writeFieldEnd();
9200 }
9201 if (defined $self->{userException}) {
9202 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
9203 $xfer += $self->{userException}->write($output);
9204 $xfer += $output->writeFieldEnd();
9205 }
9206 if (defined $self->{systemException}) {
9207 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
9208 $xfer += $self->{systemException}->write($output);
9209 $xfer += $output->writeFieldEnd();
9210 }
9211 if (defined $self->{notFoundException}) {
9212 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
9213 $xfer += $self->{notFoundException}->write($output);
9214 $xfer += $output->writeFieldEnd();
9215 }
9216 $xfer += $output->writeFieldStop();
9217 $xfer += $output->writeStructEnd();
9218 return $xfer;
9219 }
9220  
9221 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args;
9222 use base qw(Class::Accessor);
9223 Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->mk_accessors( qw( authenticationToken guid ) );
9224  
9225 sub new {
9226 my $classname = shift;
9227 my $self = {};
9228 my $vals = shift || {};
9229 $self->{authenticationToken} = undef;
9230 $self->{guid} = undef;
9231 if (UNIVERSAL::isa($vals,'HASH')) {
9232 if (defined $vals->{authenticationToken}) {
9233 $self->{authenticationToken} = $vals->{authenticationToken};
9234 }
9235 if (defined $vals->{guid}) {
9236 $self->{guid} = $vals->{guid};
9237 }
9238 }
9239 return bless ($self, $classname);
9240 }
9241  
9242 sub getName {
9243 return 'NoteStore_getResourceApplicationData_args';
9244 }
9245  
9246 sub read {
9247 my ($self, $input) = @_;
9248 my $xfer = 0;
9249 my $fname;
9250 my $ftype = 0;
9251 my $fid = 0;
9252 $xfer += $input->readStructBegin(\$fname);
9253 while (1)
9254 {
9255 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9256 if ($ftype == TType::STOP) {
9257 last;
9258 }
9259 SWITCH: for($fid)
9260 {
9261 /^1$/ && do{ if ($ftype == TType::STRING) {
9262 $xfer += $input->readString(\$self->{authenticationToken});
9263 } else {
9264 $xfer += $input->skip($ftype);
9265 }
9266 last; };
9267 /^2$/ && do{ if ($ftype == TType::STRING) {
9268 $xfer += $input->readString(\$self->{guid});
9269 } else {
9270 $xfer += $input->skip($ftype);
9271 }
9272 last; };
9273 $xfer += $input->skip($ftype);
9274 }
9275 $xfer += $input->readFieldEnd();
9276 }
9277 $xfer += $input->readStructEnd();
9278 return $xfer;
9279 }
9280  
9281 sub write {
9282 my ($self, $output) = @_;
9283 my $xfer = 0;
9284 $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationData_args');
9285 if (defined $self->{authenticationToken}) {
9286 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
9287 $xfer += $output->writeString($self->{authenticationToken});
9288 $xfer += $output->writeFieldEnd();
9289 }
9290 if (defined $self->{guid}) {
9291 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
9292 $xfer += $output->writeString($self->{guid});
9293 $xfer += $output->writeFieldEnd();
9294 }
9295 $xfer += $output->writeFieldStop();
9296 $xfer += $output->writeStructEnd();
9297 return $xfer;
9298 }
9299  
9300 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result;
9301 use base qw(Class::Accessor);
9302 Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->mk_accessors( qw( success ) );
9303  
9304 sub new {
9305 my $classname = shift;
9306 my $self = {};
9307 my $vals = shift || {};
9308 $self->{success} = undef;
9309 $self->{userException} = undef;
9310 $self->{systemException} = undef;
9311 $self->{notFoundException} = undef;
9312 if (UNIVERSAL::isa($vals,'HASH')) {
9313 if (defined $vals->{success}) {
9314 $self->{success} = $vals->{success};
9315 }
9316 if (defined $vals->{userException}) {
9317 $self->{userException} = $vals->{userException};
9318 }
9319 if (defined $vals->{systemException}) {
9320 $self->{systemException} = $vals->{systemException};
9321 }
9322 if (defined $vals->{notFoundException}) {
9323 $self->{notFoundException} = $vals->{notFoundException};
9324 }
9325 }
9326 return bless ($self, $classname);
9327 }
9328  
9329 sub getName {
9330 return 'NoteStore_getResourceApplicationData_result';
9331 }
9332  
9333 sub read {
9334 my ($self, $input) = @_;
9335 my $xfer = 0;
9336 my $fname;
9337 my $ftype = 0;
9338 my $fid = 0;
9339 $xfer += $input->readStructBegin(\$fname);
9340 while (1)
9341 {
9342 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9343 if ($ftype == TType::STOP) {
9344 last;
9345 }
9346 SWITCH: for($fid)
9347 {
9348 /^0$/ && do{ if ($ftype == TType::STRUCT) {
9349 $self->{success} = Net::Evernote::EDAMTypes::LazyMap->new();
9350 $xfer += $self->{success}->read($input);
9351 } else {
9352 $xfer += $input->skip($ftype);
9353 }
9354 last; };
9355 /^1$/ && do{ if ($ftype == TType::STRUCT) {
9356 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
9357 $xfer += $self->{userException}->read($input);
9358 } else {
9359 $xfer += $input->skip($ftype);
9360 }
9361 last; };
9362 /^2$/ && do{ if ($ftype == TType::STRUCT) {
9363 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
9364 $xfer += $self->{systemException}->read($input);
9365 } else {
9366 $xfer += $input->skip($ftype);
9367 }
9368 last; };
9369 /^3$/ && do{ if ($ftype == TType::STRUCT) {
9370 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
9371 $xfer += $self->{notFoundException}->read($input);
9372 } else {
9373 $xfer += $input->skip($ftype);
9374 }
9375 last; };
9376 $xfer += $input->skip($ftype);
9377 }
9378 $xfer += $input->readFieldEnd();
9379 }
9380 $xfer += $input->readStructEnd();
9381 return $xfer;
9382 }
9383  
9384 sub write {
9385 my ($self, $output) = @_;
9386 my $xfer = 0;
9387 $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationData_result');
9388 if (defined $self->{success}) {
9389 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
9390 $xfer += $self->{success}->write($output);
9391 $xfer += $output->writeFieldEnd();
9392 }
9393 if (defined $self->{userException}) {
9394 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
9395 $xfer += $self->{userException}->write($output);
9396 $xfer += $output->writeFieldEnd();
9397 }
9398 if (defined $self->{systemException}) {
9399 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
9400 $xfer += $self->{systemException}->write($output);
9401 $xfer += $output->writeFieldEnd();
9402 }
9403 if (defined $self->{notFoundException}) {
9404 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
9405 $xfer += $self->{notFoundException}->write($output);
9406 $xfer += $output->writeFieldEnd();
9407 }
9408 $xfer += $output->writeFieldStop();
9409 $xfer += $output->writeStructEnd();
9410 return $xfer;
9411 }
9412  
9413 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args;
9414 use base qw(Class::Accessor);
9415 Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );
9416  
9417 sub new {
9418 my $classname = shift;
9419 my $self = {};
9420 my $vals = shift || {};
9421 $self->{authenticationToken} = undef;
9422 $self->{guid} = undef;
9423 $self->{key} = undef;
9424 if (UNIVERSAL::isa($vals,'HASH')) {
9425 if (defined $vals->{authenticationToken}) {
9426 $self->{authenticationToken} = $vals->{authenticationToken};
9427 }
9428 if (defined $vals->{guid}) {
9429 $self->{guid} = $vals->{guid};
9430 }
9431 if (defined $vals->{key}) {
9432 $self->{key} = $vals->{key};
9433 }
9434 }
9435 return bless ($self, $classname);
9436 }
9437  
9438 sub getName {
9439 return 'NoteStore_getResourceApplicationDataEntry_args';
9440 }
9441  
9442 sub read {
9443 my ($self, $input) = @_;
9444 my $xfer = 0;
9445 my $fname;
9446 my $ftype = 0;
9447 my $fid = 0;
9448 $xfer += $input->readStructBegin(\$fname);
9449 while (1)
9450 {
9451 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9452 if ($ftype == TType::STOP) {
9453 last;
9454 }
9455 SWITCH: for($fid)
9456 {
9457 /^1$/ && do{ if ($ftype == TType::STRING) {
9458 $xfer += $input->readString(\$self->{authenticationToken});
9459 } else {
9460 $xfer += $input->skip($ftype);
9461 }
9462 last; };
9463 /^2$/ && do{ if ($ftype == TType::STRING) {
9464 $xfer += $input->readString(\$self->{guid});
9465 } else {
9466 $xfer += $input->skip($ftype);
9467 }
9468 last; };
9469 /^3$/ && do{ if ($ftype == TType::STRING) {
9470 $xfer += $input->readString(\$self->{key});
9471 } else {
9472 $xfer += $input->skip($ftype);
9473 }
9474 last; };
9475 $xfer += $input->skip($ftype);
9476 }
9477 $xfer += $input->readFieldEnd();
9478 }
9479 $xfer += $input->readStructEnd();
9480 return $xfer;
9481 }
9482  
9483 sub write {
9484 my ($self, $output) = @_;
9485 my $xfer = 0;
9486 $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationDataEntry_args');
9487 if (defined $self->{authenticationToken}) {
9488 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
9489 $xfer += $output->writeString($self->{authenticationToken});
9490 $xfer += $output->writeFieldEnd();
9491 }
9492 if (defined $self->{guid}) {
9493 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
9494 $xfer += $output->writeString($self->{guid});
9495 $xfer += $output->writeFieldEnd();
9496 }
9497 if (defined $self->{key}) {
9498 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
9499 $xfer += $output->writeString($self->{key});
9500 $xfer += $output->writeFieldEnd();
9501 }
9502 $xfer += $output->writeFieldStop();
9503 $xfer += $output->writeStructEnd();
9504 return $xfer;
9505 }
9506  
9507 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result;
9508 use base qw(Class::Accessor);
9509 Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->mk_accessors( qw( success ) );
9510  
9511 sub new {
9512 my $classname = shift;
9513 my $self = {};
9514 my $vals = shift || {};
9515 $self->{success} = undef;
9516 $self->{userException} = undef;
9517 $self->{systemException} = undef;
9518 $self->{notFoundException} = undef;
9519 if (UNIVERSAL::isa($vals,'HASH')) {
9520 if (defined $vals->{success}) {
9521 $self->{success} = $vals->{success};
9522 }
9523 if (defined $vals->{userException}) {
9524 $self->{userException} = $vals->{userException};
9525 }
9526 if (defined $vals->{systemException}) {
9527 $self->{systemException} = $vals->{systemException};
9528 }
9529 if (defined $vals->{notFoundException}) {
9530 $self->{notFoundException} = $vals->{notFoundException};
9531 }
9532 }
9533 return bless ($self, $classname);
9534 }
9535  
9536 sub getName {
9537 return 'NoteStore_getResourceApplicationDataEntry_result';
9538 }
9539  
9540 sub read {
9541 my ($self, $input) = @_;
9542 my $xfer = 0;
9543 my $fname;
9544 my $ftype = 0;
9545 my $fid = 0;
9546 $xfer += $input->readStructBegin(\$fname);
9547 while (1)
9548 {
9549 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9550 if ($ftype == TType::STOP) {
9551 last;
9552 }
9553 SWITCH: for($fid)
9554 {
9555 /^0$/ && do{ if ($ftype == TType::STRING) {
9556 $xfer += $input->readString(\$self->{success});
9557 } else {
9558 $xfer += $input->skip($ftype);
9559 }
9560 last; };
9561 /^1$/ && do{ if ($ftype == TType::STRUCT) {
9562 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
9563 $xfer += $self->{userException}->read($input);
9564 } else {
9565 $xfer += $input->skip($ftype);
9566 }
9567 last; };
9568 /^2$/ && do{ if ($ftype == TType::STRUCT) {
9569 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
9570 $xfer += $self->{systemException}->read($input);
9571 } else {
9572 $xfer += $input->skip($ftype);
9573 }
9574 last; };
9575 /^3$/ && do{ if ($ftype == TType::STRUCT) {
9576 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
9577 $xfer += $self->{notFoundException}->read($input);
9578 } else {
9579 $xfer += $input->skip($ftype);
9580 }
9581 last; };
9582 $xfer += $input->skip($ftype);
9583 }
9584 $xfer += $input->readFieldEnd();
9585 }
9586 $xfer += $input->readStructEnd();
9587 return $xfer;
9588 }
9589  
9590 sub write {
9591 my ($self, $output) = @_;
9592 my $xfer = 0;
9593 $xfer += $output->writeStructBegin('NoteStore_getResourceApplicationDataEntry_result');
9594 if (defined $self->{success}) {
9595 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
9596 $xfer += $output->writeString($self->{success});
9597 $xfer += $output->writeFieldEnd();
9598 }
9599 if (defined $self->{userException}) {
9600 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
9601 $xfer += $self->{userException}->write($output);
9602 $xfer += $output->writeFieldEnd();
9603 }
9604 if (defined $self->{systemException}) {
9605 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
9606 $xfer += $self->{systemException}->write($output);
9607 $xfer += $output->writeFieldEnd();
9608 }
9609 if (defined $self->{notFoundException}) {
9610 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
9611 $xfer += $self->{notFoundException}->write($output);
9612 $xfer += $output->writeFieldEnd();
9613 }
9614 $xfer += $output->writeFieldStop();
9615 $xfer += $output->writeStructEnd();
9616 return $xfer;
9617 }
9618  
9619 package Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args;
9620 use base qw(Class::Accessor);
9621 Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key value ) );
9622  
9623 sub new {
9624 my $classname = shift;
9625 my $self = {};
9626 my $vals = shift || {};
9627 $self->{authenticationToken} = undef;
9628 $self->{guid} = undef;
9629 $self->{key} = undef;
9630 $self->{value} = undef;
9631 if (UNIVERSAL::isa($vals,'HASH')) {
9632 if (defined $vals->{authenticationToken}) {
9633 $self->{authenticationToken} = $vals->{authenticationToken};
9634 }
9635 if (defined $vals->{guid}) {
9636 $self->{guid} = $vals->{guid};
9637 }
9638 if (defined $vals->{key}) {
9639 $self->{key} = $vals->{key};
9640 }
9641 if (defined $vals->{value}) {
9642 $self->{value} = $vals->{value};
9643 }
9644 }
9645 return bless ($self, $classname);
9646 }
9647  
9648 sub getName {
9649 return 'NoteStore_setResourceApplicationDataEntry_args';
9650 }
9651  
9652 sub read {
9653 my ($self, $input) = @_;
9654 my $xfer = 0;
9655 my $fname;
9656 my $ftype = 0;
9657 my $fid = 0;
9658 $xfer += $input->readStructBegin(\$fname);
9659 while (1)
9660 {
9661 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9662 if ($ftype == TType::STOP) {
9663 last;
9664 }
9665 SWITCH: for($fid)
9666 {
9667 /^1$/ && do{ if ($ftype == TType::STRING) {
9668 $xfer += $input->readString(\$self->{authenticationToken});
9669 } else {
9670 $xfer += $input->skip($ftype);
9671 }
9672 last; };
9673 /^2$/ && do{ if ($ftype == TType::STRING) {
9674 $xfer += $input->readString(\$self->{guid});
9675 } else {
9676 $xfer += $input->skip($ftype);
9677 }
9678 last; };
9679 /^3$/ && do{ if ($ftype == TType::STRING) {
9680 $xfer += $input->readString(\$self->{key});
9681 } else {
9682 $xfer += $input->skip($ftype);
9683 }
9684 last; };
9685 /^4$/ && do{ if ($ftype == TType::STRING) {
9686 $xfer += $input->readString(\$self->{value});
9687 } else {
9688 $xfer += $input->skip($ftype);
9689 }
9690 last; };
9691 $xfer += $input->skip($ftype);
9692 }
9693 $xfer += $input->readFieldEnd();
9694 }
9695 $xfer += $input->readStructEnd();
9696 return $xfer;
9697 }
9698  
9699 sub write {
9700 my ($self, $output) = @_;
9701 my $xfer = 0;
9702 $xfer += $output->writeStructBegin('NoteStore_setResourceApplicationDataEntry_args');
9703 if (defined $self->{authenticationToken}) {
9704 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
9705 $xfer += $output->writeString($self->{authenticationToken});
9706 $xfer += $output->writeFieldEnd();
9707 }
9708 if (defined $self->{guid}) {
9709 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
9710 $xfer += $output->writeString($self->{guid});
9711 $xfer += $output->writeFieldEnd();
9712 }
9713 if (defined $self->{key}) {
9714 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
9715 $xfer += $output->writeString($self->{key});
9716 $xfer += $output->writeFieldEnd();
9717 }
9718 if (defined $self->{value}) {
9719 $xfer += $output->writeFieldBegin('value', TType::STRING, 4);
9720 $xfer += $output->writeString($self->{value});
9721 $xfer += $output->writeFieldEnd();
9722 }
9723 $xfer += $output->writeFieldStop();
9724 $xfer += $output->writeStructEnd();
9725 return $xfer;
9726 }
9727  
9728 package Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result;
9729 use base qw(Class::Accessor);
9730 Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->mk_accessors( qw( success ) );
9731  
9732 sub new {
9733 my $classname = shift;
9734 my $self = {};
9735 my $vals = shift || {};
9736 $self->{success} = undef;
9737 $self->{userException} = undef;
9738 $self->{systemException} = undef;
9739 $self->{notFoundException} = undef;
9740 if (UNIVERSAL::isa($vals,'HASH')) {
9741 if (defined $vals->{success}) {
9742 $self->{success} = $vals->{success};
9743 }
9744 if (defined $vals->{userException}) {
9745 $self->{userException} = $vals->{userException};
9746 }
9747 if (defined $vals->{systemException}) {
9748 $self->{systemException} = $vals->{systemException};
9749 }
9750 if (defined $vals->{notFoundException}) {
9751 $self->{notFoundException} = $vals->{notFoundException};
9752 }
9753 }
9754 return bless ($self, $classname);
9755 }
9756  
9757 sub getName {
9758 return 'NoteStore_setResourceApplicationDataEntry_result';
9759 }
9760  
9761 sub read {
9762 my ($self, $input) = @_;
9763 my $xfer = 0;
9764 my $fname;
9765 my $ftype = 0;
9766 my $fid = 0;
9767 $xfer += $input->readStructBegin(\$fname);
9768 while (1)
9769 {
9770 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9771 if ($ftype == TType::STOP) {
9772 last;
9773 }
9774 SWITCH: for($fid)
9775 {
9776 /^0$/ && do{ if ($ftype == TType::I32) {
9777 $xfer += $input->readI32(\$self->{success});
9778 } else {
9779 $xfer += $input->skip($ftype);
9780 }
9781 last; };
9782 /^1$/ && do{ if ($ftype == TType::STRUCT) {
9783 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
9784 $xfer += $self->{userException}->read($input);
9785 } else {
9786 $xfer += $input->skip($ftype);
9787 }
9788 last; };
9789 /^2$/ && do{ if ($ftype == TType::STRUCT) {
9790 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
9791 $xfer += $self->{systemException}->read($input);
9792 } else {
9793 $xfer += $input->skip($ftype);
9794 }
9795 last; };
9796 /^3$/ && do{ if ($ftype == TType::STRUCT) {
9797 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
9798 $xfer += $self->{notFoundException}->read($input);
9799 } else {
9800 $xfer += $input->skip($ftype);
9801 }
9802 last; };
9803 $xfer += $input->skip($ftype);
9804 }
9805 $xfer += $input->readFieldEnd();
9806 }
9807 $xfer += $input->readStructEnd();
9808 return $xfer;
9809 }
9810  
9811 sub write {
9812 my ($self, $output) = @_;
9813 my $xfer = 0;
9814 $xfer += $output->writeStructBegin('NoteStore_setResourceApplicationDataEntry_result');
9815 if (defined $self->{success}) {
9816 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
9817 $xfer += $output->writeI32($self->{success});
9818 $xfer += $output->writeFieldEnd();
9819 }
9820 if (defined $self->{userException}) {
9821 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
9822 $xfer += $self->{userException}->write($output);
9823 $xfer += $output->writeFieldEnd();
9824 }
9825 if (defined $self->{systemException}) {
9826 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
9827 $xfer += $self->{systemException}->write($output);
9828 $xfer += $output->writeFieldEnd();
9829 }
9830 if (defined $self->{notFoundException}) {
9831 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
9832 $xfer += $self->{notFoundException}->write($output);
9833 $xfer += $output->writeFieldEnd();
9834 }
9835 $xfer += $output->writeFieldStop();
9836 $xfer += $output->writeStructEnd();
9837 return $xfer;
9838 }
9839  
9840 package Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args;
9841 use base qw(Class::Accessor);
9842 Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->mk_accessors( qw( authenticationToken guid key ) );
9843  
9844 sub new {
9845 my $classname = shift;
9846 my $self = {};
9847 my $vals = shift || {};
9848 $self->{authenticationToken} = undef;
9849 $self->{guid} = undef;
9850 $self->{key} = undef;
9851 if (UNIVERSAL::isa($vals,'HASH')) {
9852 if (defined $vals->{authenticationToken}) {
9853 $self->{authenticationToken} = $vals->{authenticationToken};
9854 }
9855 if (defined $vals->{guid}) {
9856 $self->{guid} = $vals->{guid};
9857 }
9858 if (defined $vals->{key}) {
9859 $self->{key} = $vals->{key};
9860 }
9861 }
9862 return bless ($self, $classname);
9863 }
9864  
9865 sub getName {
9866 return 'NoteStore_unsetResourceApplicationDataEntry_args';
9867 }
9868  
9869 sub read {
9870 my ($self, $input) = @_;
9871 my $xfer = 0;
9872 my $fname;
9873 my $ftype = 0;
9874 my $fid = 0;
9875 $xfer += $input->readStructBegin(\$fname);
9876 while (1)
9877 {
9878 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9879 if ($ftype == TType::STOP) {
9880 last;
9881 }
9882 SWITCH: for($fid)
9883 {
9884 /^1$/ && do{ if ($ftype == TType::STRING) {
9885 $xfer += $input->readString(\$self->{authenticationToken});
9886 } else {
9887 $xfer += $input->skip($ftype);
9888 }
9889 last; };
9890 /^2$/ && do{ if ($ftype == TType::STRING) {
9891 $xfer += $input->readString(\$self->{guid});
9892 } else {
9893 $xfer += $input->skip($ftype);
9894 }
9895 last; };
9896 /^3$/ && do{ if ($ftype == TType::STRING) {
9897 $xfer += $input->readString(\$self->{key});
9898 } else {
9899 $xfer += $input->skip($ftype);
9900 }
9901 last; };
9902 $xfer += $input->skip($ftype);
9903 }
9904 $xfer += $input->readFieldEnd();
9905 }
9906 $xfer += $input->readStructEnd();
9907 return $xfer;
9908 }
9909  
9910 sub write {
9911 my ($self, $output) = @_;
9912 my $xfer = 0;
9913 $xfer += $output->writeStructBegin('NoteStore_unsetResourceApplicationDataEntry_args');
9914 if (defined $self->{authenticationToken}) {
9915 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
9916 $xfer += $output->writeString($self->{authenticationToken});
9917 $xfer += $output->writeFieldEnd();
9918 }
9919 if (defined $self->{guid}) {
9920 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
9921 $xfer += $output->writeString($self->{guid});
9922 $xfer += $output->writeFieldEnd();
9923 }
9924 if (defined $self->{key}) {
9925 $xfer += $output->writeFieldBegin('key', TType::STRING, 3);
9926 $xfer += $output->writeString($self->{key});
9927 $xfer += $output->writeFieldEnd();
9928 }
9929 $xfer += $output->writeFieldStop();
9930 $xfer += $output->writeStructEnd();
9931 return $xfer;
9932 }
9933  
9934 package Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result;
9935 use base qw(Class::Accessor);
9936 Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->mk_accessors( qw( success ) );
9937  
9938 sub new {
9939 my $classname = shift;
9940 my $self = {};
9941 my $vals = shift || {};
9942 $self->{success} = undef;
9943 $self->{userException} = undef;
9944 $self->{systemException} = undef;
9945 $self->{notFoundException} = undef;
9946 if (UNIVERSAL::isa($vals,'HASH')) {
9947 if (defined $vals->{success}) {
9948 $self->{success} = $vals->{success};
9949 }
9950 if (defined $vals->{userException}) {
9951 $self->{userException} = $vals->{userException};
9952 }
9953 if (defined $vals->{systemException}) {
9954 $self->{systemException} = $vals->{systemException};
9955 }
9956 if (defined $vals->{notFoundException}) {
9957 $self->{notFoundException} = $vals->{notFoundException};
9958 }
9959 }
9960 return bless ($self, $classname);
9961 }
9962  
9963 sub getName {
9964 return 'NoteStore_unsetResourceApplicationDataEntry_result';
9965 }
9966  
9967 sub read {
9968 my ($self, $input) = @_;
9969 my $xfer = 0;
9970 my $fname;
9971 my $ftype = 0;
9972 my $fid = 0;
9973 $xfer += $input->readStructBegin(\$fname);
9974 while (1)
9975 {
9976 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
9977 if ($ftype == TType::STOP) {
9978 last;
9979 }
9980 SWITCH: for($fid)
9981 {
9982 /^0$/ && do{ if ($ftype == TType::I32) {
9983 $xfer += $input->readI32(\$self->{success});
9984 } else {
9985 $xfer += $input->skip($ftype);
9986 }
9987 last; };
9988 /^1$/ && do{ if ($ftype == TType::STRUCT) {
9989 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
9990 $xfer += $self->{userException}->read($input);
9991 } else {
9992 $xfer += $input->skip($ftype);
9993 }
9994 last; };
9995 /^2$/ && do{ if ($ftype == TType::STRUCT) {
9996 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
9997 $xfer += $self->{systemException}->read($input);
9998 } else {
9999 $xfer += $input->skip($ftype);
10000 }
10001 last; };
10002 /^3$/ && do{ if ($ftype == TType::STRUCT) {
10003 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
10004 $xfer += $self->{notFoundException}->read($input);
10005 } else {
10006 $xfer += $input->skip($ftype);
10007 }
10008 last; };
10009 $xfer += $input->skip($ftype);
10010 }
10011 $xfer += $input->readFieldEnd();
10012 }
10013 $xfer += $input->readStructEnd();
10014 return $xfer;
10015 }
10016  
10017 sub write {
10018 my ($self, $output) = @_;
10019 my $xfer = 0;
10020 $xfer += $output->writeStructBegin('NoteStore_unsetResourceApplicationDataEntry_result');
10021 if (defined $self->{success}) {
10022 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
10023 $xfer += $output->writeI32($self->{success});
10024 $xfer += $output->writeFieldEnd();
10025 }
10026 if (defined $self->{userException}) {
10027 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
10028 $xfer += $self->{userException}->write($output);
10029 $xfer += $output->writeFieldEnd();
10030 }
10031 if (defined $self->{systemException}) {
10032 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
10033 $xfer += $self->{systemException}->write($output);
10034 $xfer += $output->writeFieldEnd();
10035 }
10036 if (defined $self->{notFoundException}) {
10037 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
10038 $xfer += $self->{notFoundException}->write($output);
10039 $xfer += $output->writeFieldEnd();
10040 }
10041 $xfer += $output->writeFieldStop();
10042 $xfer += $output->writeStructEnd();
10043 return $xfer;
10044 }
10045  
10046 package Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args;
10047 use base qw(Class::Accessor);
10048 Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->mk_accessors( qw( authenticationToken resource ) );
10049  
10050 sub new {
10051 my $classname = shift;
10052 my $self = {};
10053 my $vals = shift || {};
10054 $self->{authenticationToken} = undef;
10055 $self->{resource} = undef;
10056 if (UNIVERSAL::isa($vals,'HASH')) {
10057 if (defined $vals->{authenticationToken}) {
10058 $self->{authenticationToken} = $vals->{authenticationToken};
10059 }
10060 if (defined $vals->{resource}) {
10061 $self->{resource} = $vals->{resource};
10062 }
10063 }
10064 return bless ($self, $classname);
10065 }
10066  
10067 sub getName {
10068 return 'NoteStore_updateResource_args';
10069 }
10070  
10071 sub read {
10072 my ($self, $input) = @_;
10073 my $xfer = 0;
10074 my $fname;
10075 my $ftype = 0;
10076 my $fid = 0;
10077 $xfer += $input->readStructBegin(\$fname);
10078 while (1)
10079 {
10080 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10081 if ($ftype == TType::STOP) {
10082 last;
10083 }
10084 SWITCH: for($fid)
10085 {
10086 /^1$/ && do{ if ($ftype == TType::STRING) {
10087 $xfer += $input->readString(\$self->{authenticationToken});
10088 } else {
10089 $xfer += $input->skip($ftype);
10090 }
10091 last; };
10092 /^2$/ && do{ if ($ftype == TType::STRUCT) {
10093 $self->{resource} = Net::Evernote::EDAMTypes::Resource->new();
10094 $xfer += $self->{resource}->read($input);
10095 } else {
10096 $xfer += $input->skip($ftype);
10097 }
10098 last; };
10099 $xfer += $input->skip($ftype);
10100 }
10101 $xfer += $input->readFieldEnd();
10102 }
10103 $xfer += $input->readStructEnd();
10104 return $xfer;
10105 }
10106  
10107 sub write {
10108 my ($self, $output) = @_;
10109 my $xfer = 0;
10110 $xfer += $output->writeStructBegin('NoteStore_updateResource_args');
10111 if (defined $self->{authenticationToken}) {
10112 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
10113 $xfer += $output->writeString($self->{authenticationToken});
10114 $xfer += $output->writeFieldEnd();
10115 }
10116 if (defined $self->{resource}) {
10117 $xfer += $output->writeFieldBegin('resource', TType::STRUCT, 2);
10118 $xfer += $self->{resource}->write($output);
10119 $xfer += $output->writeFieldEnd();
10120 }
10121 $xfer += $output->writeFieldStop();
10122 $xfer += $output->writeStructEnd();
10123 return $xfer;
10124 }
10125  
10126 package Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result;
10127 use base qw(Class::Accessor);
10128 Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->mk_accessors( qw( success ) );
10129  
10130 sub new {
10131 my $classname = shift;
10132 my $self = {};
10133 my $vals = shift || {};
10134 $self->{success} = undef;
10135 $self->{userException} = undef;
10136 $self->{systemException} = undef;
10137 $self->{notFoundException} = undef;
10138 if (UNIVERSAL::isa($vals,'HASH')) {
10139 if (defined $vals->{success}) {
10140 $self->{success} = $vals->{success};
10141 }
10142 if (defined $vals->{userException}) {
10143 $self->{userException} = $vals->{userException};
10144 }
10145 if (defined $vals->{systemException}) {
10146 $self->{systemException} = $vals->{systemException};
10147 }
10148 if (defined $vals->{notFoundException}) {
10149 $self->{notFoundException} = $vals->{notFoundException};
10150 }
10151 }
10152 return bless ($self, $classname);
10153 }
10154  
10155 sub getName {
10156 return 'NoteStore_updateResource_result';
10157 }
10158  
10159 sub read {
10160 my ($self, $input) = @_;
10161 my $xfer = 0;
10162 my $fname;
10163 my $ftype = 0;
10164 my $fid = 0;
10165 $xfer += $input->readStructBegin(\$fname);
10166 while (1)
10167 {
10168 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10169 if ($ftype == TType::STOP) {
10170 last;
10171 }
10172 SWITCH: for($fid)
10173 {
10174 /^0$/ && do{ if ($ftype == TType::I32) {
10175 $xfer += $input->readI32(\$self->{success});
10176 } else {
10177 $xfer += $input->skip($ftype);
10178 }
10179 last; };
10180 /^1$/ && do{ if ($ftype == TType::STRUCT) {
10181 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
10182 $xfer += $self->{userException}->read($input);
10183 } else {
10184 $xfer += $input->skip($ftype);
10185 }
10186 last; };
10187 /^2$/ && do{ if ($ftype == TType::STRUCT) {
10188 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
10189 $xfer += $self->{systemException}->read($input);
10190 } else {
10191 $xfer += $input->skip($ftype);
10192 }
10193 last; };
10194 /^3$/ && do{ if ($ftype == TType::STRUCT) {
10195 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
10196 $xfer += $self->{notFoundException}->read($input);
10197 } else {
10198 $xfer += $input->skip($ftype);
10199 }
10200 last; };
10201 $xfer += $input->skip($ftype);
10202 }
10203 $xfer += $input->readFieldEnd();
10204 }
10205 $xfer += $input->readStructEnd();
10206 return $xfer;
10207 }
10208  
10209 sub write {
10210 my ($self, $output) = @_;
10211 my $xfer = 0;
10212 $xfer += $output->writeStructBegin('NoteStore_updateResource_result');
10213 if (defined $self->{success}) {
10214 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
10215 $xfer += $output->writeI32($self->{success});
10216 $xfer += $output->writeFieldEnd();
10217 }
10218 if (defined $self->{userException}) {
10219 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
10220 $xfer += $self->{userException}->write($output);
10221 $xfer += $output->writeFieldEnd();
10222 }
10223 if (defined $self->{systemException}) {
10224 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
10225 $xfer += $self->{systemException}->write($output);
10226 $xfer += $output->writeFieldEnd();
10227 }
10228 if (defined $self->{notFoundException}) {
10229 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
10230 $xfer += $self->{notFoundException}->write($output);
10231 $xfer += $output->writeFieldEnd();
10232 }
10233 $xfer += $output->writeFieldStop();
10234 $xfer += $output->writeStructEnd();
10235 return $xfer;
10236 }
10237  
10238 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args;
10239 use base qw(Class::Accessor);
10240 Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->mk_accessors( qw( authenticationToken guid ) );
10241  
10242 sub new {
10243 my $classname = shift;
10244 my $self = {};
10245 my $vals = shift || {};
10246 $self->{authenticationToken} = undef;
10247 $self->{guid} = undef;
10248 if (UNIVERSAL::isa($vals,'HASH')) {
10249 if (defined $vals->{authenticationToken}) {
10250 $self->{authenticationToken} = $vals->{authenticationToken};
10251 }
10252 if (defined $vals->{guid}) {
10253 $self->{guid} = $vals->{guid};
10254 }
10255 }
10256 return bless ($self, $classname);
10257 }
10258  
10259 sub getName {
10260 return 'NoteStore_getResourceData_args';
10261 }
10262  
10263 sub read {
10264 my ($self, $input) = @_;
10265 my $xfer = 0;
10266 my $fname;
10267 my $ftype = 0;
10268 my $fid = 0;
10269 $xfer += $input->readStructBegin(\$fname);
10270 while (1)
10271 {
10272 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10273 if ($ftype == TType::STOP) {
10274 last;
10275 }
10276 SWITCH: for($fid)
10277 {
10278 /^1$/ && do{ if ($ftype == TType::STRING) {
10279 $xfer += $input->readString(\$self->{authenticationToken});
10280 } else {
10281 $xfer += $input->skip($ftype);
10282 }
10283 last; };
10284 /^2$/ && do{ if ($ftype == TType::STRING) {
10285 $xfer += $input->readString(\$self->{guid});
10286 } else {
10287 $xfer += $input->skip($ftype);
10288 }
10289 last; };
10290 $xfer += $input->skip($ftype);
10291 }
10292 $xfer += $input->readFieldEnd();
10293 }
10294 $xfer += $input->readStructEnd();
10295 return $xfer;
10296 }
10297  
10298 sub write {
10299 my ($self, $output) = @_;
10300 my $xfer = 0;
10301 $xfer += $output->writeStructBegin('NoteStore_getResourceData_args');
10302 if (defined $self->{authenticationToken}) {
10303 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
10304 $xfer += $output->writeString($self->{authenticationToken});
10305 $xfer += $output->writeFieldEnd();
10306 }
10307 if (defined $self->{guid}) {
10308 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
10309 $xfer += $output->writeString($self->{guid});
10310 $xfer += $output->writeFieldEnd();
10311 }
10312 $xfer += $output->writeFieldStop();
10313 $xfer += $output->writeStructEnd();
10314 return $xfer;
10315 }
10316  
10317 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result;
10318 use base qw(Class::Accessor);
10319 Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->mk_accessors( qw( success ) );
10320  
10321 sub new {
10322 my $classname = shift;
10323 my $self = {};
10324 my $vals = shift || {};
10325 $self->{success} = undef;
10326 $self->{userException} = undef;
10327 $self->{systemException} = undef;
10328 $self->{notFoundException} = undef;
10329 if (UNIVERSAL::isa($vals,'HASH')) {
10330 if (defined $vals->{success}) {
10331 $self->{success} = $vals->{success};
10332 }
10333 if (defined $vals->{userException}) {
10334 $self->{userException} = $vals->{userException};
10335 }
10336 if (defined $vals->{systemException}) {
10337 $self->{systemException} = $vals->{systemException};
10338 }
10339 if (defined $vals->{notFoundException}) {
10340 $self->{notFoundException} = $vals->{notFoundException};
10341 }
10342 }
10343 return bless ($self, $classname);
10344 }
10345  
10346 sub getName {
10347 return 'NoteStore_getResourceData_result';
10348 }
10349  
10350 sub read {
10351 my ($self, $input) = @_;
10352 my $xfer = 0;
10353 my $fname;
10354 my $ftype = 0;
10355 my $fid = 0;
10356 $xfer += $input->readStructBegin(\$fname);
10357 while (1)
10358 {
10359 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10360 if ($ftype == TType::STOP) {
10361 last;
10362 }
10363 SWITCH: for($fid)
10364 {
10365 /^0$/ && do{ if ($ftype == TType::STRING) {
10366 $xfer += $input->readString(\$self->{success});
10367 } else {
10368 $xfer += $input->skip($ftype);
10369 }
10370 last; };
10371 /^1$/ && do{ if ($ftype == TType::STRUCT) {
10372 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
10373 $xfer += $self->{userException}->read($input);
10374 } else {
10375 $xfer += $input->skip($ftype);
10376 }
10377 last; };
10378 /^2$/ && do{ if ($ftype == TType::STRUCT) {
10379 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
10380 $xfer += $self->{systemException}->read($input);
10381 } else {
10382 $xfer += $input->skip($ftype);
10383 }
10384 last; };
10385 /^3$/ && do{ if ($ftype == TType::STRUCT) {
10386 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
10387 $xfer += $self->{notFoundException}->read($input);
10388 } else {
10389 $xfer += $input->skip($ftype);
10390 }
10391 last; };
10392 $xfer += $input->skip($ftype);
10393 }
10394 $xfer += $input->readFieldEnd();
10395 }
10396 $xfer += $input->readStructEnd();
10397 return $xfer;
10398 }
10399  
10400 sub write {
10401 my ($self, $output) = @_;
10402 my $xfer = 0;
10403 $xfer += $output->writeStructBegin('NoteStore_getResourceData_result');
10404 if (defined $self->{success}) {
10405 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
10406 $xfer += $output->writeString($self->{success});
10407 $xfer += $output->writeFieldEnd();
10408 }
10409 if (defined $self->{userException}) {
10410 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
10411 $xfer += $self->{userException}->write($output);
10412 $xfer += $output->writeFieldEnd();
10413 }
10414 if (defined $self->{systemException}) {
10415 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
10416 $xfer += $self->{systemException}->write($output);
10417 $xfer += $output->writeFieldEnd();
10418 }
10419 if (defined $self->{notFoundException}) {
10420 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
10421 $xfer += $self->{notFoundException}->write($output);
10422 $xfer += $output->writeFieldEnd();
10423 }
10424 $xfer += $output->writeFieldStop();
10425 $xfer += $output->writeStructEnd();
10426 return $xfer;
10427 }
10428  
10429 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args;
10430 use base qw(Class::Accessor);
10431 Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->mk_accessors( qw( authenticationToken noteGuid contentHash withData withRecognition withAlternateData ) );
10432  
10433 sub new {
10434 my $classname = shift;
10435 my $self = {};
10436 my $vals = shift || {};
10437 $self->{authenticationToken} = undef;
10438 $self->{noteGuid} = undef;
10439 $self->{contentHash} = undef;
10440 $self->{withData} = undef;
10441 $self->{withRecognition} = undef;
10442 $self->{withAlternateData} = undef;
10443 if (UNIVERSAL::isa($vals,'HASH')) {
10444 if (defined $vals->{authenticationToken}) {
10445 $self->{authenticationToken} = $vals->{authenticationToken};
10446 }
10447 if (defined $vals->{noteGuid}) {
10448 $self->{noteGuid} = $vals->{noteGuid};
10449 }
10450 if (defined $vals->{contentHash}) {
10451 $self->{contentHash} = $vals->{contentHash};
10452 }
10453 if (defined $vals->{withData}) {
10454 $self->{withData} = $vals->{withData};
10455 }
10456 if (defined $vals->{withRecognition}) {
10457 $self->{withRecognition} = $vals->{withRecognition};
10458 }
10459 if (defined $vals->{withAlternateData}) {
10460 $self->{withAlternateData} = $vals->{withAlternateData};
10461 }
10462 }
10463 return bless ($self, $classname);
10464 }
10465  
10466 sub getName {
10467 return 'NoteStore_getResourceByHash_args';
10468 }
10469  
10470 sub read {
10471 my ($self, $input) = @_;
10472 my $xfer = 0;
10473 my $fname;
10474 my $ftype = 0;
10475 my $fid = 0;
10476 $xfer += $input->readStructBegin(\$fname);
10477 while (1)
10478 {
10479 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10480 if ($ftype == TType::STOP) {
10481 last;
10482 }
10483 SWITCH: for($fid)
10484 {
10485 /^1$/ && do{ if ($ftype == TType::STRING) {
10486 $xfer += $input->readString(\$self->{authenticationToken});
10487 } else {
10488 $xfer += $input->skip($ftype);
10489 }
10490 last; };
10491 /^2$/ && do{ if ($ftype == TType::STRING) {
10492 $xfer += $input->readString(\$self->{noteGuid});
10493 } else {
10494 $xfer += $input->skip($ftype);
10495 }
10496 last; };
10497 /^3$/ && do{ if ($ftype == TType::STRING) {
10498 $xfer += $input->readString(\$self->{contentHash});
10499 } else {
10500 $xfer += $input->skip($ftype);
10501 }
10502 last; };
10503 /^4$/ && do{ if ($ftype == TType::BOOL) {
10504 $xfer += $input->readBool(\$self->{withData});
10505 } else {
10506 $xfer += $input->skip($ftype);
10507 }
10508 last; };
10509 /^5$/ && do{ if ($ftype == TType::BOOL) {
10510 $xfer += $input->readBool(\$self->{withRecognition});
10511 } else {
10512 $xfer += $input->skip($ftype);
10513 }
10514 last; };
10515 /^6$/ && do{ if ($ftype == TType::BOOL) {
10516 $xfer += $input->readBool(\$self->{withAlternateData});
10517 } else {
10518 $xfer += $input->skip($ftype);
10519 }
10520 last; };
10521 $xfer += $input->skip($ftype);
10522 }
10523 $xfer += $input->readFieldEnd();
10524 }
10525 $xfer += $input->readStructEnd();
10526 return $xfer;
10527 }
10528  
10529 sub write {
10530 my ($self, $output) = @_;
10531 my $xfer = 0;
10532 $xfer += $output->writeStructBegin('NoteStore_getResourceByHash_args');
10533 if (defined $self->{authenticationToken}) {
10534 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
10535 $xfer += $output->writeString($self->{authenticationToken});
10536 $xfer += $output->writeFieldEnd();
10537 }
10538 if (defined $self->{noteGuid}) {
10539 $xfer += $output->writeFieldBegin('noteGuid', TType::STRING, 2);
10540 $xfer += $output->writeString($self->{noteGuid});
10541 $xfer += $output->writeFieldEnd();
10542 }
10543 if (defined $self->{contentHash}) {
10544 $xfer += $output->writeFieldBegin('contentHash', TType::STRING, 3);
10545 $xfer += $output->writeString($self->{contentHash});
10546 $xfer += $output->writeFieldEnd();
10547 }
10548 if (defined $self->{withData}) {
10549 $xfer += $output->writeFieldBegin('withData', TType::BOOL, 4);
10550 $xfer += $output->writeBool($self->{withData});
10551 $xfer += $output->writeFieldEnd();
10552 }
10553 if (defined $self->{withRecognition}) {
10554 $xfer += $output->writeFieldBegin('withRecognition', TType::BOOL, 5);
10555 $xfer += $output->writeBool($self->{withRecognition});
10556 $xfer += $output->writeFieldEnd();
10557 }
10558 if (defined $self->{withAlternateData}) {
10559 $xfer += $output->writeFieldBegin('withAlternateData', TType::BOOL, 6);
10560 $xfer += $output->writeBool($self->{withAlternateData});
10561 $xfer += $output->writeFieldEnd();
10562 }
10563 $xfer += $output->writeFieldStop();
10564 $xfer += $output->writeStructEnd();
10565 return $xfer;
10566 }
10567  
10568 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result;
10569 use base qw(Class::Accessor);
10570 Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->mk_accessors( qw( success ) );
10571  
10572 sub new {
10573 my $classname = shift;
10574 my $self = {};
10575 my $vals = shift || {};
10576 $self->{success} = undef;
10577 $self->{userException} = undef;
10578 $self->{systemException} = undef;
10579 $self->{notFoundException} = undef;
10580 if (UNIVERSAL::isa($vals,'HASH')) {
10581 if (defined $vals->{success}) {
10582 $self->{success} = $vals->{success};
10583 }
10584 if (defined $vals->{userException}) {
10585 $self->{userException} = $vals->{userException};
10586 }
10587 if (defined $vals->{systemException}) {
10588 $self->{systemException} = $vals->{systemException};
10589 }
10590 if (defined $vals->{notFoundException}) {
10591 $self->{notFoundException} = $vals->{notFoundException};
10592 }
10593 }
10594 return bless ($self, $classname);
10595 }
10596  
10597 sub getName {
10598 return 'NoteStore_getResourceByHash_result';
10599 }
10600  
10601 sub read {
10602 my ($self, $input) = @_;
10603 my $xfer = 0;
10604 my $fname;
10605 my $ftype = 0;
10606 my $fid = 0;
10607 $xfer += $input->readStructBegin(\$fname);
10608 while (1)
10609 {
10610 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10611 if ($ftype == TType::STOP) {
10612 last;
10613 }
10614 SWITCH: for($fid)
10615 {
10616 /^0$/ && do{ if ($ftype == TType::STRUCT) {
10617 $self->{success} = Net::Evernote::EDAMTypes::Resource->new();
10618 $xfer += $self->{success}->read($input);
10619 } else {
10620 $xfer += $input->skip($ftype);
10621 }
10622 last; };
10623 /^1$/ && do{ if ($ftype == TType::STRUCT) {
10624 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
10625 $xfer += $self->{userException}->read($input);
10626 } else {
10627 $xfer += $input->skip($ftype);
10628 }
10629 last; };
10630 /^2$/ && do{ if ($ftype == TType::STRUCT) {
10631 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
10632 $xfer += $self->{systemException}->read($input);
10633 } else {
10634 $xfer += $input->skip($ftype);
10635 }
10636 last; };
10637 /^3$/ && do{ if ($ftype == TType::STRUCT) {
10638 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
10639 $xfer += $self->{notFoundException}->read($input);
10640 } else {
10641 $xfer += $input->skip($ftype);
10642 }
10643 last; };
10644 $xfer += $input->skip($ftype);
10645 }
10646 $xfer += $input->readFieldEnd();
10647 }
10648 $xfer += $input->readStructEnd();
10649 return $xfer;
10650 }
10651  
10652 sub write {
10653 my ($self, $output) = @_;
10654 my $xfer = 0;
10655 $xfer += $output->writeStructBegin('NoteStore_getResourceByHash_result');
10656 if (defined $self->{success}) {
10657 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
10658 $xfer += $self->{success}->write($output);
10659 $xfer += $output->writeFieldEnd();
10660 }
10661 if (defined $self->{userException}) {
10662 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
10663 $xfer += $self->{userException}->write($output);
10664 $xfer += $output->writeFieldEnd();
10665 }
10666 if (defined $self->{systemException}) {
10667 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
10668 $xfer += $self->{systemException}->write($output);
10669 $xfer += $output->writeFieldEnd();
10670 }
10671 if (defined $self->{notFoundException}) {
10672 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
10673 $xfer += $self->{notFoundException}->write($output);
10674 $xfer += $output->writeFieldEnd();
10675 }
10676 $xfer += $output->writeFieldStop();
10677 $xfer += $output->writeStructEnd();
10678 return $xfer;
10679 }
10680  
10681 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args;
10682 use base qw(Class::Accessor);
10683 Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->mk_accessors( qw( authenticationToken guid ) );
10684  
10685 sub new {
10686 my $classname = shift;
10687 my $self = {};
10688 my $vals = shift || {};
10689 $self->{authenticationToken} = undef;
10690 $self->{guid} = undef;
10691 if (UNIVERSAL::isa($vals,'HASH')) {
10692 if (defined $vals->{authenticationToken}) {
10693 $self->{authenticationToken} = $vals->{authenticationToken};
10694 }
10695 if (defined $vals->{guid}) {
10696 $self->{guid} = $vals->{guid};
10697 }
10698 }
10699 return bless ($self, $classname);
10700 }
10701  
10702 sub getName {
10703 return 'NoteStore_getResourceRecognition_args';
10704 }
10705  
10706 sub read {
10707 my ($self, $input) = @_;
10708 my $xfer = 0;
10709 my $fname;
10710 my $ftype = 0;
10711 my $fid = 0;
10712 $xfer += $input->readStructBegin(\$fname);
10713 while (1)
10714 {
10715 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10716 if ($ftype == TType::STOP) {
10717 last;
10718 }
10719 SWITCH: for($fid)
10720 {
10721 /^1$/ && do{ if ($ftype == TType::STRING) {
10722 $xfer += $input->readString(\$self->{authenticationToken});
10723 } else {
10724 $xfer += $input->skip($ftype);
10725 }
10726 last; };
10727 /^2$/ && do{ if ($ftype == TType::STRING) {
10728 $xfer += $input->readString(\$self->{guid});
10729 } else {
10730 $xfer += $input->skip($ftype);
10731 }
10732 last; };
10733 $xfer += $input->skip($ftype);
10734 }
10735 $xfer += $input->readFieldEnd();
10736 }
10737 $xfer += $input->readStructEnd();
10738 return $xfer;
10739 }
10740  
10741 sub write {
10742 my ($self, $output) = @_;
10743 my $xfer = 0;
10744 $xfer += $output->writeStructBegin('NoteStore_getResourceRecognition_args');
10745 if (defined $self->{authenticationToken}) {
10746 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
10747 $xfer += $output->writeString($self->{authenticationToken});
10748 $xfer += $output->writeFieldEnd();
10749 }
10750 if (defined $self->{guid}) {
10751 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
10752 $xfer += $output->writeString($self->{guid});
10753 $xfer += $output->writeFieldEnd();
10754 }
10755 $xfer += $output->writeFieldStop();
10756 $xfer += $output->writeStructEnd();
10757 return $xfer;
10758 }
10759  
10760 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result;
10761 use base qw(Class::Accessor);
10762 Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->mk_accessors( qw( success ) );
10763  
10764 sub new {
10765 my $classname = shift;
10766 my $self = {};
10767 my $vals = shift || {};
10768 $self->{success} = undef;
10769 $self->{userException} = undef;
10770 $self->{systemException} = undef;
10771 $self->{notFoundException} = undef;
10772 if (UNIVERSAL::isa($vals,'HASH')) {
10773 if (defined $vals->{success}) {
10774 $self->{success} = $vals->{success};
10775 }
10776 if (defined $vals->{userException}) {
10777 $self->{userException} = $vals->{userException};
10778 }
10779 if (defined $vals->{systemException}) {
10780 $self->{systemException} = $vals->{systemException};
10781 }
10782 if (defined $vals->{notFoundException}) {
10783 $self->{notFoundException} = $vals->{notFoundException};
10784 }
10785 }
10786 return bless ($self, $classname);
10787 }
10788  
10789 sub getName {
10790 return 'NoteStore_getResourceRecognition_result';
10791 }
10792  
10793 sub read {
10794 my ($self, $input) = @_;
10795 my $xfer = 0;
10796 my $fname;
10797 my $ftype = 0;
10798 my $fid = 0;
10799 $xfer += $input->readStructBegin(\$fname);
10800 while (1)
10801 {
10802 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10803 if ($ftype == TType::STOP) {
10804 last;
10805 }
10806 SWITCH: for($fid)
10807 {
10808 /^0$/ && do{ if ($ftype == TType::STRING) {
10809 $xfer += $input->readString(\$self->{success});
10810 } else {
10811 $xfer += $input->skip($ftype);
10812 }
10813 last; };
10814 /^1$/ && do{ if ($ftype == TType::STRUCT) {
10815 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
10816 $xfer += $self->{userException}->read($input);
10817 } else {
10818 $xfer += $input->skip($ftype);
10819 }
10820 last; };
10821 /^2$/ && do{ if ($ftype == TType::STRUCT) {
10822 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
10823 $xfer += $self->{systemException}->read($input);
10824 } else {
10825 $xfer += $input->skip($ftype);
10826 }
10827 last; };
10828 /^3$/ && do{ if ($ftype == TType::STRUCT) {
10829 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
10830 $xfer += $self->{notFoundException}->read($input);
10831 } else {
10832 $xfer += $input->skip($ftype);
10833 }
10834 last; };
10835 $xfer += $input->skip($ftype);
10836 }
10837 $xfer += $input->readFieldEnd();
10838 }
10839 $xfer += $input->readStructEnd();
10840 return $xfer;
10841 }
10842  
10843 sub write {
10844 my ($self, $output) = @_;
10845 my $xfer = 0;
10846 $xfer += $output->writeStructBegin('NoteStore_getResourceRecognition_result');
10847 if (defined $self->{success}) {
10848 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
10849 $xfer += $output->writeString($self->{success});
10850 $xfer += $output->writeFieldEnd();
10851 }
10852 if (defined $self->{userException}) {
10853 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
10854 $xfer += $self->{userException}->write($output);
10855 $xfer += $output->writeFieldEnd();
10856 }
10857 if (defined $self->{systemException}) {
10858 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
10859 $xfer += $self->{systemException}->write($output);
10860 $xfer += $output->writeFieldEnd();
10861 }
10862 if (defined $self->{notFoundException}) {
10863 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
10864 $xfer += $self->{notFoundException}->write($output);
10865 $xfer += $output->writeFieldEnd();
10866 }
10867 $xfer += $output->writeFieldStop();
10868 $xfer += $output->writeStructEnd();
10869 return $xfer;
10870 }
10871  
10872 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args;
10873 use base qw(Class::Accessor);
10874 Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->mk_accessors( qw( authenticationToken guid ) );
10875  
10876 sub new {
10877 my $classname = shift;
10878 my $self = {};
10879 my $vals = shift || {};
10880 $self->{authenticationToken} = undef;
10881 $self->{guid} = undef;
10882 if (UNIVERSAL::isa($vals,'HASH')) {
10883 if (defined $vals->{authenticationToken}) {
10884 $self->{authenticationToken} = $vals->{authenticationToken};
10885 }
10886 if (defined $vals->{guid}) {
10887 $self->{guid} = $vals->{guid};
10888 }
10889 }
10890 return bless ($self, $classname);
10891 }
10892  
10893 sub getName {
10894 return 'NoteStore_getResourceAlternateData_args';
10895 }
10896  
10897 sub read {
10898 my ($self, $input) = @_;
10899 my $xfer = 0;
10900 my $fname;
10901 my $ftype = 0;
10902 my $fid = 0;
10903 $xfer += $input->readStructBegin(\$fname);
10904 while (1)
10905 {
10906 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10907 if ($ftype == TType::STOP) {
10908 last;
10909 }
10910 SWITCH: for($fid)
10911 {
10912 /^1$/ && do{ if ($ftype == TType::STRING) {
10913 $xfer += $input->readString(\$self->{authenticationToken});
10914 } else {
10915 $xfer += $input->skip($ftype);
10916 }
10917 last; };
10918 /^2$/ && do{ if ($ftype == TType::STRING) {
10919 $xfer += $input->readString(\$self->{guid});
10920 } else {
10921 $xfer += $input->skip($ftype);
10922 }
10923 last; };
10924 $xfer += $input->skip($ftype);
10925 }
10926 $xfer += $input->readFieldEnd();
10927 }
10928 $xfer += $input->readStructEnd();
10929 return $xfer;
10930 }
10931  
10932 sub write {
10933 my ($self, $output) = @_;
10934 my $xfer = 0;
10935 $xfer += $output->writeStructBegin('NoteStore_getResourceAlternateData_args');
10936 if (defined $self->{authenticationToken}) {
10937 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
10938 $xfer += $output->writeString($self->{authenticationToken});
10939 $xfer += $output->writeFieldEnd();
10940 }
10941 if (defined $self->{guid}) {
10942 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
10943 $xfer += $output->writeString($self->{guid});
10944 $xfer += $output->writeFieldEnd();
10945 }
10946 $xfer += $output->writeFieldStop();
10947 $xfer += $output->writeStructEnd();
10948 return $xfer;
10949 }
10950  
10951 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result;
10952 use base qw(Class::Accessor);
10953 Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->mk_accessors( qw( success ) );
10954  
10955 sub new {
10956 my $classname = shift;
10957 my $self = {};
10958 my $vals = shift || {};
10959 $self->{success} = undef;
10960 $self->{userException} = undef;
10961 $self->{systemException} = undef;
10962 $self->{notFoundException} = undef;
10963 if (UNIVERSAL::isa($vals,'HASH')) {
10964 if (defined $vals->{success}) {
10965 $self->{success} = $vals->{success};
10966 }
10967 if (defined $vals->{userException}) {
10968 $self->{userException} = $vals->{userException};
10969 }
10970 if (defined $vals->{systemException}) {
10971 $self->{systemException} = $vals->{systemException};
10972 }
10973 if (defined $vals->{notFoundException}) {
10974 $self->{notFoundException} = $vals->{notFoundException};
10975 }
10976 }
10977 return bless ($self, $classname);
10978 }
10979  
10980 sub getName {
10981 return 'NoteStore_getResourceAlternateData_result';
10982 }
10983  
10984 sub read {
10985 my ($self, $input) = @_;
10986 my $xfer = 0;
10987 my $fname;
10988 my $ftype = 0;
10989 my $fid = 0;
10990 $xfer += $input->readStructBegin(\$fname);
10991 while (1)
10992 {
10993 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
10994 if ($ftype == TType::STOP) {
10995 last;
10996 }
10997 SWITCH: for($fid)
10998 {
10999 /^0$/ && do{ if ($ftype == TType::STRING) {
11000 $xfer += $input->readString(\$self->{success});
11001 } else {
11002 $xfer += $input->skip($ftype);
11003 }
11004 last; };
11005 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11006 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
11007 $xfer += $self->{userException}->read($input);
11008 } else {
11009 $xfer += $input->skip($ftype);
11010 }
11011 last; };
11012 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11013 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11014 $xfer += $self->{systemException}->read($input);
11015 } else {
11016 $xfer += $input->skip($ftype);
11017 }
11018 last; };
11019 /^3$/ && do{ if ($ftype == TType::STRUCT) {
11020 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
11021 $xfer += $self->{notFoundException}->read($input);
11022 } else {
11023 $xfer += $input->skip($ftype);
11024 }
11025 last; };
11026 $xfer += $input->skip($ftype);
11027 }
11028 $xfer += $input->readFieldEnd();
11029 }
11030 $xfer += $input->readStructEnd();
11031 return $xfer;
11032 }
11033  
11034 sub write {
11035 my ($self, $output) = @_;
11036 my $xfer = 0;
11037 $xfer += $output->writeStructBegin('NoteStore_getResourceAlternateData_result');
11038 if (defined $self->{success}) {
11039 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
11040 $xfer += $output->writeString($self->{success});
11041 $xfer += $output->writeFieldEnd();
11042 }
11043 if (defined $self->{userException}) {
11044 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
11045 $xfer += $self->{userException}->write($output);
11046 $xfer += $output->writeFieldEnd();
11047 }
11048 if (defined $self->{systemException}) {
11049 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
11050 $xfer += $self->{systemException}->write($output);
11051 $xfer += $output->writeFieldEnd();
11052 }
11053 if (defined $self->{notFoundException}) {
11054 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
11055 $xfer += $self->{notFoundException}->write($output);
11056 $xfer += $output->writeFieldEnd();
11057 }
11058 $xfer += $output->writeFieldStop();
11059 $xfer += $output->writeStructEnd();
11060 return $xfer;
11061 }
11062  
11063 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args;
11064 use base qw(Class::Accessor);
11065 Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->mk_accessors( qw( authenticationToken guid ) );
11066  
11067 sub new {
11068 my $classname = shift;
11069 my $self = {};
11070 my $vals = shift || {};
11071 $self->{authenticationToken} = undef;
11072 $self->{guid} = undef;
11073 if (UNIVERSAL::isa($vals,'HASH')) {
11074 if (defined $vals->{authenticationToken}) {
11075 $self->{authenticationToken} = $vals->{authenticationToken};
11076 }
11077 if (defined $vals->{guid}) {
11078 $self->{guid} = $vals->{guid};
11079 }
11080 }
11081 return bless ($self, $classname);
11082 }
11083  
11084 sub getName {
11085 return 'NoteStore_getResourceAttributes_args';
11086 }
11087  
11088 sub read {
11089 my ($self, $input) = @_;
11090 my $xfer = 0;
11091 my $fname;
11092 my $ftype = 0;
11093 my $fid = 0;
11094 $xfer += $input->readStructBegin(\$fname);
11095 while (1)
11096 {
11097 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11098 if ($ftype == TType::STOP) {
11099 last;
11100 }
11101 SWITCH: for($fid)
11102 {
11103 /^1$/ && do{ if ($ftype == TType::STRING) {
11104 $xfer += $input->readString(\$self->{authenticationToken});
11105 } else {
11106 $xfer += $input->skip($ftype);
11107 }
11108 last; };
11109 /^2$/ && do{ if ($ftype == TType::STRING) {
11110 $xfer += $input->readString(\$self->{guid});
11111 } else {
11112 $xfer += $input->skip($ftype);
11113 }
11114 last; };
11115 $xfer += $input->skip($ftype);
11116 }
11117 $xfer += $input->readFieldEnd();
11118 }
11119 $xfer += $input->readStructEnd();
11120 return $xfer;
11121 }
11122  
11123 sub write {
11124 my ($self, $output) = @_;
11125 my $xfer = 0;
11126 $xfer += $output->writeStructBegin('NoteStore_getResourceAttributes_args');
11127 if (defined $self->{authenticationToken}) {
11128 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
11129 $xfer += $output->writeString($self->{authenticationToken});
11130 $xfer += $output->writeFieldEnd();
11131 }
11132 if (defined $self->{guid}) {
11133 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
11134 $xfer += $output->writeString($self->{guid});
11135 $xfer += $output->writeFieldEnd();
11136 }
11137 $xfer += $output->writeFieldStop();
11138 $xfer += $output->writeStructEnd();
11139 return $xfer;
11140 }
11141  
11142 package Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result;
11143 use base qw(Class::Accessor);
11144 Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->mk_accessors( qw( success ) );
11145  
11146 sub new {
11147 my $classname = shift;
11148 my $self = {};
11149 my $vals = shift || {};
11150 $self->{success} = undef;
11151 $self->{userException} = undef;
11152 $self->{systemException} = undef;
11153 $self->{notFoundException} = undef;
11154 if (UNIVERSAL::isa($vals,'HASH')) {
11155 if (defined $vals->{success}) {
11156 $self->{success} = $vals->{success};
11157 }
11158 if (defined $vals->{userException}) {
11159 $self->{userException} = $vals->{userException};
11160 }
11161 if (defined $vals->{systemException}) {
11162 $self->{systemException} = $vals->{systemException};
11163 }
11164 if (defined $vals->{notFoundException}) {
11165 $self->{notFoundException} = $vals->{notFoundException};
11166 }
11167 }
11168 return bless ($self, $classname);
11169 }
11170  
11171 sub getName {
11172 return 'NoteStore_getResourceAttributes_result';
11173 }
11174  
11175 sub read {
11176 my ($self, $input) = @_;
11177 my $xfer = 0;
11178 my $fname;
11179 my $ftype = 0;
11180 my $fid = 0;
11181 $xfer += $input->readStructBegin(\$fname);
11182 while (1)
11183 {
11184 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11185 if ($ftype == TType::STOP) {
11186 last;
11187 }
11188 SWITCH: for($fid)
11189 {
11190 /^0$/ && do{ if ($ftype == TType::STRUCT) {
11191 $self->{success} = Net::Evernote::EDAMTypes::ResourceAttributes->new();
11192 $xfer += $self->{success}->read($input);
11193 } else {
11194 $xfer += $input->skip($ftype);
11195 }
11196 last; };
11197 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11198 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
11199 $xfer += $self->{userException}->read($input);
11200 } else {
11201 $xfer += $input->skip($ftype);
11202 }
11203 last; };
11204 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11205 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11206 $xfer += $self->{systemException}->read($input);
11207 } else {
11208 $xfer += $input->skip($ftype);
11209 }
11210 last; };
11211 /^3$/ && do{ if ($ftype == TType::STRUCT) {
11212 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
11213 $xfer += $self->{notFoundException}->read($input);
11214 } else {
11215 $xfer += $input->skip($ftype);
11216 }
11217 last; };
11218 $xfer += $input->skip($ftype);
11219 }
11220 $xfer += $input->readFieldEnd();
11221 }
11222 $xfer += $input->readStructEnd();
11223 return $xfer;
11224 }
11225  
11226 sub write {
11227 my ($self, $output) = @_;
11228 my $xfer = 0;
11229 $xfer += $output->writeStructBegin('NoteStore_getResourceAttributes_result');
11230 if (defined $self->{success}) {
11231 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
11232 $xfer += $self->{success}->write($output);
11233 $xfer += $output->writeFieldEnd();
11234 }
11235 if (defined $self->{userException}) {
11236 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
11237 $xfer += $self->{userException}->write($output);
11238 $xfer += $output->writeFieldEnd();
11239 }
11240 if (defined $self->{systemException}) {
11241 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
11242 $xfer += $self->{systemException}->write($output);
11243 $xfer += $output->writeFieldEnd();
11244 }
11245 if (defined $self->{notFoundException}) {
11246 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 3);
11247 $xfer += $self->{notFoundException}->write($output);
11248 $xfer += $output->writeFieldEnd();
11249 }
11250 $xfer += $output->writeFieldStop();
11251 $xfer += $output->writeStructEnd();
11252 return $xfer;
11253 }
11254  
11255 package Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args;
11256 use base qw(Class::Accessor);
11257 Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->mk_accessors( qw( authenticationToken ) );
11258  
11259 sub new {
11260 my $classname = shift;
11261 my $self = {};
11262 my $vals = shift || {};
11263 $self->{authenticationToken} = undef;
11264 if (UNIVERSAL::isa($vals,'HASH')) {
11265 if (defined $vals->{authenticationToken}) {
11266 $self->{authenticationToken} = $vals->{authenticationToken};
11267 }
11268 }
11269 return bless ($self, $classname);
11270 }
11271  
11272 sub getName {
11273 return 'NoteStore_getAccountSize_args';
11274 }
11275  
11276 sub read {
11277 my ($self, $input) = @_;
11278 my $xfer = 0;
11279 my $fname;
11280 my $ftype = 0;
11281 my $fid = 0;
11282 $xfer += $input->readStructBegin(\$fname);
11283 while (1)
11284 {
11285 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11286 if ($ftype == TType::STOP) {
11287 last;
11288 }
11289 SWITCH: for($fid)
11290 {
11291 /^1$/ && do{ if ($ftype == TType::STRING) {
11292 $xfer += $input->readString(\$self->{authenticationToken});
11293 } else {
11294 $xfer += $input->skip($ftype);
11295 }
11296 last; };
11297 $xfer += $input->skip($ftype);
11298 }
11299 $xfer += $input->readFieldEnd();
11300 }
11301 $xfer += $input->readStructEnd();
11302 return $xfer;
11303 }
11304  
11305 sub write {
11306 my ($self, $output) = @_;
11307 my $xfer = 0;
11308 $xfer += $output->writeStructBegin('NoteStore_getAccountSize_args');
11309 if (defined $self->{authenticationToken}) {
11310 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
11311 $xfer += $output->writeString($self->{authenticationToken});
11312 $xfer += $output->writeFieldEnd();
11313 }
11314 $xfer += $output->writeFieldStop();
11315 $xfer += $output->writeStructEnd();
11316 return $xfer;
11317 }
11318  
11319 package Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result;
11320 use base qw(Class::Accessor);
11321 Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->mk_accessors( qw( success ) );
11322  
11323 sub new {
11324 my $classname = shift;
11325 my $self = {};
11326 my $vals = shift || {};
11327 $self->{success} = undef;
11328 $self->{userException} = undef;
11329 $self->{systemException} = undef;
11330 if (UNIVERSAL::isa($vals,'HASH')) {
11331 if (defined $vals->{success}) {
11332 $self->{success} = $vals->{success};
11333 }
11334 if (defined $vals->{userException}) {
11335 $self->{userException} = $vals->{userException};
11336 }
11337 if (defined $vals->{systemException}) {
11338 $self->{systemException} = $vals->{systemException};
11339 }
11340 }
11341 return bless ($self, $classname);
11342 }
11343  
11344 sub getName {
11345 return 'NoteStore_getAccountSize_result';
11346 }
11347  
11348 sub read {
11349 my ($self, $input) = @_;
11350 my $xfer = 0;
11351 my $fname;
11352 my $ftype = 0;
11353 my $fid = 0;
11354 $xfer += $input->readStructBegin(\$fname);
11355 while (1)
11356 {
11357 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11358 if ($ftype == TType::STOP) {
11359 last;
11360 }
11361 SWITCH: for($fid)
11362 {
11363 /^0$/ && do{ if ($ftype == TType::I64) {
11364 $xfer += $input->readI64(\$self->{success});
11365 } else {
11366 $xfer += $input->skip($ftype);
11367 }
11368 last; };
11369 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11370 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
11371 $xfer += $self->{userException}->read($input);
11372 } else {
11373 $xfer += $input->skip($ftype);
11374 }
11375 last; };
11376 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11377 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11378 $xfer += $self->{systemException}->read($input);
11379 } else {
11380 $xfer += $input->skip($ftype);
11381 }
11382 last; };
11383 $xfer += $input->skip($ftype);
11384 }
11385 $xfer += $input->readFieldEnd();
11386 }
11387 $xfer += $input->readStructEnd();
11388 return $xfer;
11389 }
11390  
11391 sub write {
11392 my ($self, $output) = @_;
11393 my $xfer = 0;
11394 $xfer += $output->writeStructBegin('NoteStore_getAccountSize_result');
11395 if (defined $self->{success}) {
11396 $xfer += $output->writeFieldBegin('success', TType::I64, 0);
11397 $xfer += $output->writeI64($self->{success});
11398 $xfer += $output->writeFieldEnd();
11399 }
11400 if (defined $self->{userException}) {
11401 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
11402 $xfer += $self->{userException}->write($output);
11403 $xfer += $output->writeFieldEnd();
11404 }
11405 if (defined $self->{systemException}) {
11406 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
11407 $xfer += $self->{systemException}->write($output);
11408 $xfer += $output->writeFieldEnd();
11409 }
11410 $xfer += $output->writeFieldStop();
11411 $xfer += $output->writeStructEnd();
11412 return $xfer;
11413 }
11414  
11415 package Net::Evernote::EDAMNoteStore::NoteStore_getAds_args;
11416 use base qw(Class::Accessor);
11417 Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->mk_accessors( qw( authenticationToken adParameters ) );
11418  
11419 sub new {
11420 my $classname = shift;
11421 my $self = {};
11422 my $vals = shift || {};
11423 $self->{authenticationToken} = undef;
11424 $self->{adParameters} = undef;
11425 if (UNIVERSAL::isa($vals,'HASH')) {
11426 if (defined $vals->{authenticationToken}) {
11427 $self->{authenticationToken} = $vals->{authenticationToken};
11428 }
11429 if (defined $vals->{adParameters}) {
11430 $self->{adParameters} = $vals->{adParameters};
11431 }
11432 }
11433 return bless ($self, $classname);
11434 }
11435  
11436 sub getName {
11437 return 'NoteStore_getAds_args';
11438 }
11439  
11440 sub read {
11441 my ($self, $input) = @_;
11442 my $xfer = 0;
11443 my $fname;
11444 my $ftype = 0;
11445 my $fid = 0;
11446 $xfer += $input->readStructBegin(\$fname);
11447 while (1)
11448 {
11449 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11450 if ($ftype == TType::STOP) {
11451 last;
11452 }
11453 SWITCH: for($fid)
11454 {
11455 /^1$/ && do{ if ($ftype == TType::STRING) {
11456 $xfer += $input->readString(\$self->{authenticationToken});
11457 } else {
11458 $xfer += $input->skip($ftype);
11459 }
11460 last; };
11461 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11462 $self->{adParameters} = Net::Evernote::EDAMNoteStore::AdParameters->new();
11463 $xfer += $self->{adParameters}->read($input);
11464 } else {
11465 $xfer += $input->skip($ftype);
11466 }
11467 last; };
11468 $xfer += $input->skip($ftype);
11469 }
11470 $xfer += $input->readFieldEnd();
11471 }
11472 $xfer += $input->readStructEnd();
11473 return $xfer;
11474 }
11475  
11476 sub write {
11477 my ($self, $output) = @_;
11478 my $xfer = 0;
11479 $xfer += $output->writeStructBegin('NoteStore_getAds_args');
11480 if (defined $self->{authenticationToken}) {
11481 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
11482 $xfer += $output->writeString($self->{authenticationToken});
11483 $xfer += $output->writeFieldEnd();
11484 }
11485 if (defined $self->{adParameters}) {
11486 $xfer += $output->writeFieldBegin('adParameters', TType::STRUCT, 2);
11487 $xfer += $self->{adParameters}->write($output);
11488 $xfer += $output->writeFieldEnd();
11489 }
11490 $xfer += $output->writeFieldStop();
11491 $xfer += $output->writeStructEnd();
11492 return $xfer;
11493 }
11494  
11495 package Net::Evernote::EDAMNoteStore::NoteStore_getAds_result;
11496 use base qw(Class::Accessor);
11497 Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->mk_accessors( qw( success ) );
11498  
11499 sub new {
11500 my $classname = shift;
11501 my $self = {};
11502 my $vals = shift || {};
11503 $self->{success} = undef;
11504 $self->{userException} = undef;
11505 $self->{systemException} = undef;
11506 if (UNIVERSAL::isa($vals,'HASH')) {
11507 if (defined $vals->{success}) {
11508 $self->{success} = $vals->{success};
11509 }
11510 if (defined $vals->{userException}) {
11511 $self->{userException} = $vals->{userException};
11512 }
11513 if (defined $vals->{systemException}) {
11514 $self->{systemException} = $vals->{systemException};
11515 }
11516 }
11517 return bless ($self, $classname);
11518 }
11519  
11520 sub getName {
11521 return 'NoteStore_getAds_result';
11522 }
11523  
11524 sub read {
11525 my ($self, $input) = @_;
11526 my $xfer = 0;
11527 my $fname;
11528 my $ftype = 0;
11529 my $fid = 0;
11530 $xfer += $input->readStructBegin(\$fname);
11531 while (1)
11532 {
11533 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11534 if ($ftype == TType::STOP) {
11535 last;
11536 }
11537 SWITCH: for($fid)
11538 {
11539 /^0$/ && do{ if ($ftype == TType::LIST) {
11540 {
11541 my $_size230 = 0;
11542 $self->{success} = [];
11543 my $_etype233 = 0;
11544 $xfer += $input->readListBegin(\$_etype233, \$_size230);
11545 for (my $_i234 = 0; $_i234 < $_size230; ++$_i234)
11546 {
11547 my $elem235 = undef;
11548 $elem235 = Net::Evernote::EDAMTypes::Ad->new();
11549 $xfer += $elem235->read($input);
11550 push(@{$self->{success}},$elem235);
11551 }
11552 $xfer += $input->readListEnd();
11553 }
11554 } else {
11555 $xfer += $input->skip($ftype);
11556 }
11557 last; };
11558 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11559 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
11560 $xfer += $self->{userException}->read($input);
11561 } else {
11562 $xfer += $input->skip($ftype);
11563 }
11564 last; };
11565 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11566 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11567 $xfer += $self->{systemException}->read($input);
11568 } else {
11569 $xfer += $input->skip($ftype);
11570 }
11571 last; };
11572 $xfer += $input->skip($ftype);
11573 }
11574 $xfer += $input->readFieldEnd();
11575 }
11576 $xfer += $input->readStructEnd();
11577 return $xfer;
11578 }
11579  
11580 sub write {
11581 my ($self, $output) = @_;
11582 my $xfer = 0;
11583 $xfer += $output->writeStructBegin('NoteStore_getAds_result');
11584 if (defined $self->{success}) {
11585 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
11586 {
11587 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
11588 {
11589 foreach my $iter236 (@{$self->{success}})
11590 {
11591 $xfer += ${iter236}->write($output);
11592 }
11593 }
11594 $xfer += $output->writeListEnd();
11595 }
11596 $xfer += $output->writeFieldEnd();
11597 }
11598 if (defined $self->{userException}) {
11599 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
11600 $xfer += $self->{userException}->write($output);
11601 $xfer += $output->writeFieldEnd();
11602 }
11603 if (defined $self->{systemException}) {
11604 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
11605 $xfer += $self->{systemException}->write($output);
11606 $xfer += $output->writeFieldEnd();
11607 }
11608 $xfer += $output->writeFieldStop();
11609 $xfer += $output->writeStructEnd();
11610 return $xfer;
11611 }
11612  
11613 package Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args;
11614 use base qw(Class::Accessor);
11615 Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->mk_accessors( qw( authenticationToken adParameters ) );
11616  
11617 sub new {
11618 my $classname = shift;
11619 my $self = {};
11620 my $vals = shift || {};
11621 $self->{authenticationToken} = undef;
11622 $self->{adParameters} = undef;
11623 if (UNIVERSAL::isa($vals,'HASH')) {
11624 if (defined $vals->{authenticationToken}) {
11625 $self->{authenticationToken} = $vals->{authenticationToken};
11626 }
11627 if (defined $vals->{adParameters}) {
11628 $self->{adParameters} = $vals->{adParameters};
11629 }
11630 }
11631 return bless ($self, $classname);
11632 }
11633  
11634 sub getName {
11635 return 'NoteStore_getRandomAd_args';
11636 }
11637  
11638 sub read {
11639 my ($self, $input) = @_;
11640 my $xfer = 0;
11641 my $fname;
11642 my $ftype = 0;
11643 my $fid = 0;
11644 $xfer += $input->readStructBegin(\$fname);
11645 while (1)
11646 {
11647 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11648 if ($ftype == TType::STOP) {
11649 last;
11650 }
11651 SWITCH: for($fid)
11652 {
11653 /^1$/ && do{ if ($ftype == TType::STRING) {
11654 $xfer += $input->readString(\$self->{authenticationToken});
11655 } else {
11656 $xfer += $input->skip($ftype);
11657 }
11658 last; };
11659 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11660 $self->{adParameters} = Net::Evernote::EDAMNoteStore::AdParameters->new();
11661 $xfer += $self->{adParameters}->read($input);
11662 } else {
11663 $xfer += $input->skip($ftype);
11664 }
11665 last; };
11666 $xfer += $input->skip($ftype);
11667 }
11668 $xfer += $input->readFieldEnd();
11669 }
11670 $xfer += $input->readStructEnd();
11671 return $xfer;
11672 }
11673  
11674 sub write {
11675 my ($self, $output) = @_;
11676 my $xfer = 0;
11677 $xfer += $output->writeStructBegin('NoteStore_getRandomAd_args');
11678 if (defined $self->{authenticationToken}) {
11679 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
11680 $xfer += $output->writeString($self->{authenticationToken});
11681 $xfer += $output->writeFieldEnd();
11682 }
11683 if (defined $self->{adParameters}) {
11684 $xfer += $output->writeFieldBegin('adParameters', TType::STRUCT, 2);
11685 $xfer += $self->{adParameters}->write($output);
11686 $xfer += $output->writeFieldEnd();
11687 }
11688 $xfer += $output->writeFieldStop();
11689 $xfer += $output->writeStructEnd();
11690 return $xfer;
11691 }
11692  
11693 package Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result;
11694 use base qw(Class::Accessor);
11695 Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->mk_accessors( qw( success ) );
11696  
11697 sub new {
11698 my $classname = shift;
11699 my $self = {};
11700 my $vals = shift || {};
11701 $self->{success} = undef;
11702 $self->{userException} = undef;
11703 $self->{systemException} = undef;
11704 if (UNIVERSAL::isa($vals,'HASH')) {
11705 if (defined $vals->{success}) {
11706 $self->{success} = $vals->{success};
11707 }
11708 if (defined $vals->{userException}) {
11709 $self->{userException} = $vals->{userException};
11710 }
11711 if (defined $vals->{systemException}) {
11712 $self->{systemException} = $vals->{systemException};
11713 }
11714 }
11715 return bless ($self, $classname);
11716 }
11717  
11718 sub getName {
11719 return 'NoteStore_getRandomAd_result';
11720 }
11721  
11722 sub read {
11723 my ($self, $input) = @_;
11724 my $xfer = 0;
11725 my $fname;
11726 my $ftype = 0;
11727 my $fid = 0;
11728 $xfer += $input->readStructBegin(\$fname);
11729 while (1)
11730 {
11731 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11732 if ($ftype == TType::STOP) {
11733 last;
11734 }
11735 SWITCH: for($fid)
11736 {
11737 /^0$/ && do{ if ($ftype == TType::STRUCT) {
11738 $self->{success} = Net::Evernote::EDAMTypes::Ad->new();
11739 $xfer += $self->{success}->read($input);
11740 } else {
11741 $xfer += $input->skip($ftype);
11742 }
11743 last; };
11744 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11745 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
11746 $xfer += $self->{userException}->read($input);
11747 } else {
11748 $xfer += $input->skip($ftype);
11749 }
11750 last; };
11751 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11752 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11753 $xfer += $self->{systemException}->read($input);
11754 } else {
11755 $xfer += $input->skip($ftype);
11756 }
11757 last; };
11758 $xfer += $input->skip($ftype);
11759 }
11760 $xfer += $input->readFieldEnd();
11761 }
11762 $xfer += $input->readStructEnd();
11763 return $xfer;
11764 }
11765  
11766 sub write {
11767 my ($self, $output) = @_;
11768 my $xfer = 0;
11769 $xfer += $output->writeStructBegin('NoteStore_getRandomAd_result');
11770 if (defined $self->{success}) {
11771 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
11772 $xfer += $self->{success}->write($output);
11773 $xfer += $output->writeFieldEnd();
11774 }
11775 if (defined $self->{userException}) {
11776 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
11777 $xfer += $self->{userException}->write($output);
11778 $xfer += $output->writeFieldEnd();
11779 }
11780 if (defined $self->{systemException}) {
11781 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 2);
11782 $xfer += $self->{systemException}->write($output);
11783 $xfer += $output->writeFieldEnd();
11784 }
11785 $xfer += $output->writeFieldStop();
11786 $xfer += $output->writeStructEnd();
11787 return $xfer;
11788 }
11789  
11790 package Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args;
11791 use base qw(Class::Accessor);
11792 Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->mk_accessors( qw( userId publicUri ) );
11793  
11794 sub new {
11795 my $classname = shift;
11796 my $self = {};
11797 my $vals = shift || {};
11798 $self->{userId} = undef;
11799 $self->{publicUri} = undef;
11800 if (UNIVERSAL::isa($vals,'HASH')) {
11801 if (defined $vals->{userId}) {
11802 $self->{userId} = $vals->{userId};
11803 }
11804 if (defined $vals->{publicUri}) {
11805 $self->{publicUri} = $vals->{publicUri};
11806 }
11807 }
11808 return bless ($self, $classname);
11809 }
11810  
11811 sub getName {
11812 return 'NoteStore_getPublicNotebook_args';
11813 }
11814  
11815 sub read {
11816 my ($self, $input) = @_;
11817 my $xfer = 0;
11818 my $fname;
11819 my $ftype = 0;
11820 my $fid = 0;
11821 $xfer += $input->readStructBegin(\$fname);
11822 while (1)
11823 {
11824 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11825 if ($ftype == TType::STOP) {
11826 last;
11827 }
11828 SWITCH: for($fid)
11829 {
11830 /^1$/ && do{ if ($ftype == TType::I32) {
11831 $xfer += $input->readI32(\$self->{userId});
11832 } else {
11833 $xfer += $input->skip($ftype);
11834 }
11835 last; };
11836 /^2$/ && do{ if ($ftype == TType::STRING) {
11837 $xfer += $input->readString(\$self->{publicUri});
11838 } else {
11839 $xfer += $input->skip($ftype);
11840 }
11841 last; };
11842 $xfer += $input->skip($ftype);
11843 }
11844 $xfer += $input->readFieldEnd();
11845 }
11846 $xfer += $input->readStructEnd();
11847 return $xfer;
11848 }
11849  
11850 sub write {
11851 my ($self, $output) = @_;
11852 my $xfer = 0;
11853 $xfer += $output->writeStructBegin('NoteStore_getPublicNotebook_args');
11854 if (defined $self->{userId}) {
11855 $xfer += $output->writeFieldBegin('userId', TType::I32, 1);
11856 $xfer += $output->writeI32($self->{userId});
11857 $xfer += $output->writeFieldEnd();
11858 }
11859 if (defined $self->{publicUri}) {
11860 $xfer += $output->writeFieldBegin('publicUri', TType::STRING, 2);
11861 $xfer += $output->writeString($self->{publicUri});
11862 $xfer += $output->writeFieldEnd();
11863 }
11864 $xfer += $output->writeFieldStop();
11865 $xfer += $output->writeStructEnd();
11866 return $xfer;
11867 }
11868  
11869 package Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result;
11870 use base qw(Class::Accessor);
11871 Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->mk_accessors( qw( success ) );
11872  
11873 sub new {
11874 my $classname = shift;
11875 my $self = {};
11876 my $vals = shift || {};
11877 $self->{success} = undef;
11878 $self->{systemException} = undef;
11879 $self->{notFoundException} = undef;
11880 if (UNIVERSAL::isa($vals,'HASH')) {
11881 if (defined $vals->{success}) {
11882 $self->{success} = $vals->{success};
11883 }
11884 if (defined $vals->{systemException}) {
11885 $self->{systemException} = $vals->{systemException};
11886 }
11887 if (defined $vals->{notFoundException}) {
11888 $self->{notFoundException} = $vals->{notFoundException};
11889 }
11890 }
11891 return bless ($self, $classname);
11892 }
11893  
11894 sub getName {
11895 return 'NoteStore_getPublicNotebook_result';
11896 }
11897  
11898 sub read {
11899 my ($self, $input) = @_;
11900 my $xfer = 0;
11901 my $fname;
11902 my $ftype = 0;
11903 my $fid = 0;
11904 $xfer += $input->readStructBegin(\$fname);
11905 while (1)
11906 {
11907 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
11908 if ($ftype == TType::STOP) {
11909 last;
11910 }
11911 SWITCH: for($fid)
11912 {
11913 /^0$/ && do{ if ($ftype == TType::STRUCT) {
11914 $self->{success} = Net::Evernote::EDAMTypes::Notebook->new();
11915 $xfer += $self->{success}->read($input);
11916 } else {
11917 $xfer += $input->skip($ftype);
11918 }
11919 last; };
11920 /^1$/ && do{ if ($ftype == TType::STRUCT) {
11921 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
11922 $xfer += $self->{systemException}->read($input);
11923 } else {
11924 $xfer += $input->skip($ftype);
11925 }
11926 last; };
11927 /^2$/ && do{ if ($ftype == TType::STRUCT) {
11928 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
11929 $xfer += $self->{notFoundException}->read($input);
11930 } else {
11931 $xfer += $input->skip($ftype);
11932 }
11933 last; };
11934 $xfer += $input->skip($ftype);
11935 }
11936 $xfer += $input->readFieldEnd();
11937 }
11938 $xfer += $input->readStructEnd();
11939 return $xfer;
11940 }
11941  
11942 sub write {
11943 my ($self, $output) = @_;
11944 my $xfer = 0;
11945 $xfer += $output->writeStructBegin('NoteStore_getPublicNotebook_result');
11946 if (defined $self->{success}) {
11947 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
11948 $xfer += $self->{success}->write($output);
11949 $xfer += $output->writeFieldEnd();
11950 }
11951 if (defined $self->{systemException}) {
11952 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 1);
11953 $xfer += $self->{systemException}->write($output);
11954 $xfer += $output->writeFieldEnd();
11955 }
11956 if (defined $self->{notFoundException}) {
11957 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
11958 $xfer += $self->{notFoundException}->write($output);
11959 $xfer += $output->writeFieldEnd();
11960 }
11961 $xfer += $output->writeFieldStop();
11962 $xfer += $output->writeStructEnd();
11963 return $xfer;
11964 }
11965  
11966 package Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args;
11967 use base qw(Class::Accessor);
11968 Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->mk_accessors( qw( authenticationToken sharedNotebook ) );
11969  
11970 sub new {
11971 my $classname = shift;
11972 my $self = {};
11973 my $vals = shift || {};
11974 $self->{authenticationToken} = undef;
11975 $self->{sharedNotebook} = undef;
11976 if (UNIVERSAL::isa($vals,'HASH')) {
11977 if (defined $vals->{authenticationToken}) {
11978 $self->{authenticationToken} = $vals->{authenticationToken};
11979 }
11980 if (defined $vals->{sharedNotebook}) {
11981 $self->{sharedNotebook} = $vals->{sharedNotebook};
11982 }
11983 }
11984 return bless ($self, $classname);
11985 }
11986  
11987 sub getName {
11988 return 'NoteStore_createSharedNotebook_args';
11989 }
11990  
11991 sub read {
11992 my ($self, $input) = @_;
11993 my $xfer = 0;
11994 my $fname;
11995 my $ftype = 0;
11996 my $fid = 0;
11997 $xfer += $input->readStructBegin(\$fname);
11998 while (1)
11999 {
12000 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12001 if ($ftype == TType::STOP) {
12002 last;
12003 }
12004 SWITCH: for($fid)
12005 {
12006 /^1$/ && do{ if ($ftype == TType::STRING) {
12007 $xfer += $input->readString(\$self->{authenticationToken});
12008 } else {
12009 $xfer += $input->skip($ftype);
12010 }
12011 last; };
12012 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12013 $self->{sharedNotebook} = Net::Evernote::EDAMTypes::SharedNotebook->new();
12014 $xfer += $self->{sharedNotebook}->read($input);
12015 } else {
12016 $xfer += $input->skip($ftype);
12017 }
12018 last; };
12019 $xfer += $input->skip($ftype);
12020 }
12021 $xfer += $input->readFieldEnd();
12022 }
12023 $xfer += $input->readStructEnd();
12024 return $xfer;
12025 }
12026  
12027 sub write {
12028 my ($self, $output) = @_;
12029 my $xfer = 0;
12030 $xfer += $output->writeStructBegin('NoteStore_createSharedNotebook_args');
12031 if (defined $self->{authenticationToken}) {
12032 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
12033 $xfer += $output->writeString($self->{authenticationToken});
12034 $xfer += $output->writeFieldEnd();
12035 }
12036 if (defined $self->{sharedNotebook}) {
12037 $xfer += $output->writeFieldBegin('sharedNotebook', TType::STRUCT, 2);
12038 $xfer += $self->{sharedNotebook}->write($output);
12039 $xfer += $output->writeFieldEnd();
12040 }
12041 $xfer += $output->writeFieldStop();
12042 $xfer += $output->writeStructEnd();
12043 return $xfer;
12044 }
12045  
12046 package Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result;
12047 use base qw(Class::Accessor);
12048 Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->mk_accessors( qw( success ) );
12049  
12050 sub new {
12051 my $classname = shift;
12052 my $self = {};
12053 my $vals = shift || {};
12054 $self->{success} = undef;
12055 $self->{userException} = undef;
12056 $self->{notFoundException} = undef;
12057 $self->{systemException} = undef;
12058 if (UNIVERSAL::isa($vals,'HASH')) {
12059 if (defined $vals->{success}) {
12060 $self->{success} = $vals->{success};
12061 }
12062 if (defined $vals->{userException}) {
12063 $self->{userException} = $vals->{userException};
12064 }
12065 if (defined $vals->{notFoundException}) {
12066 $self->{notFoundException} = $vals->{notFoundException};
12067 }
12068 if (defined $vals->{systemException}) {
12069 $self->{systemException} = $vals->{systemException};
12070 }
12071 }
12072 return bless ($self, $classname);
12073 }
12074  
12075 sub getName {
12076 return 'NoteStore_createSharedNotebook_result';
12077 }
12078  
12079 sub read {
12080 my ($self, $input) = @_;
12081 my $xfer = 0;
12082 my $fname;
12083 my $ftype = 0;
12084 my $fid = 0;
12085 $xfer += $input->readStructBegin(\$fname);
12086 while (1)
12087 {
12088 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12089 if ($ftype == TType::STOP) {
12090 last;
12091 }
12092 SWITCH: for($fid)
12093 {
12094 /^0$/ && do{ if ($ftype == TType::STRUCT) {
12095 $self->{success} = Net::Evernote::EDAMTypes::SharedNotebook->new();
12096 $xfer += $self->{success}->read($input);
12097 } else {
12098 $xfer += $input->skip($ftype);
12099 }
12100 last; };
12101 /^1$/ && do{ if ($ftype == TType::STRUCT) {
12102 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
12103 $xfer += $self->{userException}->read($input);
12104 } else {
12105 $xfer += $input->skip($ftype);
12106 }
12107 last; };
12108 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12109 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
12110 $xfer += $self->{notFoundException}->read($input);
12111 } else {
12112 $xfer += $input->skip($ftype);
12113 }
12114 last; };
12115 /^3$/ && do{ if ($ftype == TType::STRUCT) {
12116 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
12117 $xfer += $self->{systemException}->read($input);
12118 } else {
12119 $xfer += $input->skip($ftype);
12120 }
12121 last; };
12122 $xfer += $input->skip($ftype);
12123 }
12124 $xfer += $input->readFieldEnd();
12125 }
12126 $xfer += $input->readStructEnd();
12127 return $xfer;
12128 }
12129  
12130 sub write {
12131 my ($self, $output) = @_;
12132 my $xfer = 0;
12133 $xfer += $output->writeStructBegin('NoteStore_createSharedNotebook_result');
12134 if (defined $self->{success}) {
12135 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
12136 $xfer += $self->{success}->write($output);
12137 $xfer += $output->writeFieldEnd();
12138 }
12139 if (defined $self->{userException}) {
12140 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
12141 $xfer += $self->{userException}->write($output);
12142 $xfer += $output->writeFieldEnd();
12143 }
12144 if (defined $self->{notFoundException}) {
12145 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
12146 $xfer += $self->{notFoundException}->write($output);
12147 $xfer += $output->writeFieldEnd();
12148 }
12149 if (defined $self->{systemException}) {
12150 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
12151 $xfer += $self->{systemException}->write($output);
12152 $xfer += $output->writeFieldEnd();
12153 }
12154 $xfer += $output->writeFieldStop();
12155 $xfer += $output->writeStructEnd();
12156 return $xfer;
12157 }
12158  
12159 package Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args;
12160 use base qw(Class::Accessor);
12161 Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->mk_accessors( qw( authenticationToken notebookGuid messageText recipients ) );
12162  
12163 sub new {
12164 my $classname = shift;
12165 my $self = {};
12166 my $vals = shift || {};
12167 $self->{authenticationToken} = undef;
12168 $self->{notebookGuid} = undef;
12169 $self->{messageText} = undef;
12170 $self->{recipients} = undef;
12171 if (UNIVERSAL::isa($vals,'HASH')) {
12172 if (defined $vals->{authenticationToken}) {
12173 $self->{authenticationToken} = $vals->{authenticationToken};
12174 }
12175 if (defined $vals->{notebookGuid}) {
12176 $self->{notebookGuid} = $vals->{notebookGuid};
12177 }
12178 if (defined $vals->{messageText}) {
12179 $self->{messageText} = $vals->{messageText};
12180 }
12181 if (defined $vals->{recipients}) {
12182 $self->{recipients} = $vals->{recipients};
12183 }
12184 }
12185 return bless ($self, $classname);
12186 }
12187  
12188 sub getName {
12189 return 'NoteStore_sendMessageToSharedNotebookMembers_args';
12190 }
12191  
12192 sub read {
12193 my ($self, $input) = @_;
12194 my $xfer = 0;
12195 my $fname;
12196 my $ftype = 0;
12197 my $fid = 0;
12198 $xfer += $input->readStructBegin(\$fname);
12199 while (1)
12200 {
12201 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12202 if ($ftype == TType::STOP) {
12203 last;
12204 }
12205 SWITCH: for($fid)
12206 {
12207 /^1$/ && do{ if ($ftype == TType::STRING) {
12208 $xfer += $input->readString(\$self->{authenticationToken});
12209 } else {
12210 $xfer += $input->skip($ftype);
12211 }
12212 last; };
12213 /^2$/ && do{ if ($ftype == TType::STRING) {
12214 $xfer += $input->readString(\$self->{notebookGuid});
12215 } else {
12216 $xfer += $input->skip($ftype);
12217 }
12218 last; };
12219 /^3$/ && do{ if ($ftype == TType::STRING) {
12220 $xfer += $input->readString(\$self->{messageText});
12221 } else {
12222 $xfer += $input->skip($ftype);
12223 }
12224 last; };
12225 /^4$/ && do{ if ($ftype == TType::LIST) {
12226 {
12227 my $_size237 = 0;
12228 $self->{recipients} = [];
12229 my $_etype240 = 0;
12230 $xfer += $input->readListBegin(\$_etype240, \$_size237);
12231 for (my $_i241 = 0; $_i241 < $_size237; ++$_i241)
12232 {
12233 my $elem242 = undef;
12234 $xfer += $input->readString(\$elem242);
12235 push(@{$self->{recipients}},$elem242);
12236 }
12237 $xfer += $input->readListEnd();
12238 }
12239 } else {
12240 $xfer += $input->skip($ftype);
12241 }
12242 last; };
12243 $xfer += $input->skip($ftype);
12244 }
12245 $xfer += $input->readFieldEnd();
12246 }
12247 $xfer += $input->readStructEnd();
12248 return $xfer;
12249 }
12250  
12251 sub write {
12252 my ($self, $output) = @_;
12253 my $xfer = 0;
12254 $xfer += $output->writeStructBegin('NoteStore_sendMessageToSharedNotebookMembers_args');
12255 if (defined $self->{authenticationToken}) {
12256 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
12257 $xfer += $output->writeString($self->{authenticationToken});
12258 $xfer += $output->writeFieldEnd();
12259 }
12260 if (defined $self->{notebookGuid}) {
12261 $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 2);
12262 $xfer += $output->writeString($self->{notebookGuid});
12263 $xfer += $output->writeFieldEnd();
12264 }
12265 if (defined $self->{messageText}) {
12266 $xfer += $output->writeFieldBegin('messageText', TType::STRING, 3);
12267 $xfer += $output->writeString($self->{messageText});
12268 $xfer += $output->writeFieldEnd();
12269 }
12270 if (defined $self->{recipients}) {
12271 $xfer += $output->writeFieldBegin('recipients', TType::LIST, 4);
12272 {
12273 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{recipients}}));
12274 {
12275 foreach my $iter243 (@{$self->{recipients}})
12276 {
12277 $xfer += $output->writeString($iter243);
12278 }
12279 }
12280 $xfer += $output->writeListEnd();
12281 }
12282 $xfer += $output->writeFieldEnd();
12283 }
12284 $xfer += $output->writeFieldStop();
12285 $xfer += $output->writeStructEnd();
12286 return $xfer;
12287 }
12288  
12289 package Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result;
12290 use base qw(Class::Accessor);
12291 Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->mk_accessors( qw( success ) );
12292  
12293 sub new {
12294 my $classname = shift;
12295 my $self = {};
12296 my $vals = shift || {};
12297 $self->{success} = undef;
12298 $self->{userException} = undef;
12299 $self->{notFoundException} = undef;
12300 $self->{systemException} = undef;
12301 if (UNIVERSAL::isa($vals,'HASH')) {
12302 if (defined $vals->{success}) {
12303 $self->{success} = $vals->{success};
12304 }
12305 if (defined $vals->{userException}) {
12306 $self->{userException} = $vals->{userException};
12307 }
12308 if (defined $vals->{notFoundException}) {
12309 $self->{notFoundException} = $vals->{notFoundException};
12310 }
12311 if (defined $vals->{systemException}) {
12312 $self->{systemException} = $vals->{systemException};
12313 }
12314 }
12315 return bless ($self, $classname);
12316 }
12317  
12318 sub getName {
12319 return 'NoteStore_sendMessageToSharedNotebookMembers_result';
12320 }
12321  
12322 sub read {
12323 my ($self, $input) = @_;
12324 my $xfer = 0;
12325 my $fname;
12326 my $ftype = 0;
12327 my $fid = 0;
12328 $xfer += $input->readStructBegin(\$fname);
12329 while (1)
12330 {
12331 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12332 if ($ftype == TType::STOP) {
12333 last;
12334 }
12335 SWITCH: for($fid)
12336 {
12337 /^0$/ && do{ if ($ftype == TType::I32) {
12338 $xfer += $input->readI32(\$self->{success});
12339 } else {
12340 $xfer += $input->skip($ftype);
12341 }
12342 last; };
12343 /^1$/ && do{ if ($ftype == TType::STRUCT) {
12344 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
12345 $xfer += $self->{userException}->read($input);
12346 } else {
12347 $xfer += $input->skip($ftype);
12348 }
12349 last; };
12350 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12351 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
12352 $xfer += $self->{notFoundException}->read($input);
12353 } else {
12354 $xfer += $input->skip($ftype);
12355 }
12356 last; };
12357 /^3$/ && do{ if ($ftype == TType::STRUCT) {
12358 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
12359 $xfer += $self->{systemException}->read($input);
12360 } else {
12361 $xfer += $input->skip($ftype);
12362 }
12363 last; };
12364 $xfer += $input->skip($ftype);
12365 }
12366 $xfer += $input->readFieldEnd();
12367 }
12368 $xfer += $input->readStructEnd();
12369 return $xfer;
12370 }
12371  
12372 sub write {
12373 my ($self, $output) = @_;
12374 my $xfer = 0;
12375 $xfer += $output->writeStructBegin('NoteStore_sendMessageToSharedNotebookMembers_result');
12376 if (defined $self->{success}) {
12377 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
12378 $xfer += $output->writeI32($self->{success});
12379 $xfer += $output->writeFieldEnd();
12380 }
12381 if (defined $self->{userException}) {
12382 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
12383 $xfer += $self->{userException}->write($output);
12384 $xfer += $output->writeFieldEnd();
12385 }
12386 if (defined $self->{notFoundException}) {
12387 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
12388 $xfer += $self->{notFoundException}->write($output);
12389 $xfer += $output->writeFieldEnd();
12390 }
12391 if (defined $self->{systemException}) {
12392 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
12393 $xfer += $self->{systemException}->write($output);
12394 $xfer += $output->writeFieldEnd();
12395 }
12396 $xfer += $output->writeFieldStop();
12397 $xfer += $output->writeStructEnd();
12398 return $xfer;
12399 }
12400  
12401 package Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args;
12402 use base qw(Class::Accessor);
12403 Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->mk_accessors( qw( authenticationToken ) );
12404  
12405 sub new {
12406 my $classname = shift;
12407 my $self = {};
12408 my $vals = shift || {};
12409 $self->{authenticationToken} = undef;
12410 if (UNIVERSAL::isa($vals,'HASH')) {
12411 if (defined $vals->{authenticationToken}) {
12412 $self->{authenticationToken} = $vals->{authenticationToken};
12413 }
12414 }
12415 return bless ($self, $classname);
12416 }
12417  
12418 sub getName {
12419 return 'NoteStore_listSharedNotebooks_args';
12420 }
12421  
12422 sub read {
12423 my ($self, $input) = @_;
12424 my $xfer = 0;
12425 my $fname;
12426 my $ftype = 0;
12427 my $fid = 0;
12428 $xfer += $input->readStructBegin(\$fname);
12429 while (1)
12430 {
12431 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12432 if ($ftype == TType::STOP) {
12433 last;
12434 }
12435 SWITCH: for($fid)
12436 {
12437 /^1$/ && do{ if ($ftype == TType::STRING) {
12438 $xfer += $input->readString(\$self->{authenticationToken});
12439 } else {
12440 $xfer += $input->skip($ftype);
12441 }
12442 last; };
12443 $xfer += $input->skip($ftype);
12444 }
12445 $xfer += $input->readFieldEnd();
12446 }
12447 $xfer += $input->readStructEnd();
12448 return $xfer;
12449 }
12450  
12451 sub write {
12452 my ($self, $output) = @_;
12453 my $xfer = 0;
12454 $xfer += $output->writeStructBegin('NoteStore_listSharedNotebooks_args');
12455 if (defined $self->{authenticationToken}) {
12456 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
12457 $xfer += $output->writeString($self->{authenticationToken});
12458 $xfer += $output->writeFieldEnd();
12459 }
12460 $xfer += $output->writeFieldStop();
12461 $xfer += $output->writeStructEnd();
12462 return $xfer;
12463 }
12464  
12465 package Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result;
12466 use base qw(Class::Accessor);
12467 Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->mk_accessors( qw( success ) );
12468  
12469 sub new {
12470 my $classname = shift;
12471 my $self = {};
12472 my $vals = shift || {};
12473 $self->{success} = undef;
12474 $self->{userException} = undef;
12475 $self->{notFoundException} = undef;
12476 $self->{systemException} = undef;
12477 if (UNIVERSAL::isa($vals,'HASH')) {
12478 if (defined $vals->{success}) {
12479 $self->{success} = $vals->{success};
12480 }
12481 if (defined $vals->{userException}) {
12482 $self->{userException} = $vals->{userException};
12483 }
12484 if (defined $vals->{notFoundException}) {
12485 $self->{notFoundException} = $vals->{notFoundException};
12486 }
12487 if (defined $vals->{systemException}) {
12488 $self->{systemException} = $vals->{systemException};
12489 }
12490 }
12491 return bless ($self, $classname);
12492 }
12493  
12494 sub getName {
12495 return 'NoteStore_listSharedNotebooks_result';
12496 }
12497  
12498 sub read {
12499 my ($self, $input) = @_;
12500 my $xfer = 0;
12501 my $fname;
12502 my $ftype = 0;
12503 my $fid = 0;
12504 $xfer += $input->readStructBegin(\$fname);
12505 while (1)
12506 {
12507 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12508 if ($ftype == TType::STOP) {
12509 last;
12510 }
12511 SWITCH: for($fid)
12512 {
12513 /^0$/ && do{ if ($ftype == TType::LIST) {
12514 {
12515 my $_size244 = 0;
12516 $self->{success} = [];
12517 my $_etype247 = 0;
12518 $xfer += $input->readListBegin(\$_etype247, \$_size244);
12519 for (my $_i248 = 0; $_i248 < $_size244; ++$_i248)
12520 {
12521 my $elem249 = undef;
12522 $elem249 = Net::Evernote::EDAMTypes::SharedNotebook->new();
12523 $xfer += $elem249->read($input);
12524 push(@{$self->{success}},$elem249);
12525 }
12526 $xfer += $input->readListEnd();
12527 }
12528 } else {
12529 $xfer += $input->skip($ftype);
12530 }
12531 last; };
12532 /^1$/ && do{ if ($ftype == TType::STRUCT) {
12533 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
12534 $xfer += $self->{userException}->read($input);
12535 } else {
12536 $xfer += $input->skip($ftype);
12537 }
12538 last; };
12539 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12540 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
12541 $xfer += $self->{notFoundException}->read($input);
12542 } else {
12543 $xfer += $input->skip($ftype);
12544 }
12545 last; };
12546 /^3$/ && do{ if ($ftype == TType::STRUCT) {
12547 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
12548 $xfer += $self->{systemException}->read($input);
12549 } else {
12550 $xfer += $input->skip($ftype);
12551 }
12552 last; };
12553 $xfer += $input->skip($ftype);
12554 }
12555 $xfer += $input->readFieldEnd();
12556 }
12557 $xfer += $input->readStructEnd();
12558 return $xfer;
12559 }
12560  
12561 sub write {
12562 my ($self, $output) = @_;
12563 my $xfer = 0;
12564 $xfer += $output->writeStructBegin('NoteStore_listSharedNotebooks_result');
12565 if (defined $self->{success}) {
12566 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
12567 {
12568 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
12569 {
12570 foreach my $iter250 (@{$self->{success}})
12571 {
12572 $xfer += ${iter250}->write($output);
12573 }
12574 }
12575 $xfer += $output->writeListEnd();
12576 }
12577 $xfer += $output->writeFieldEnd();
12578 }
12579 if (defined $self->{userException}) {
12580 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
12581 $xfer += $self->{userException}->write($output);
12582 $xfer += $output->writeFieldEnd();
12583 }
12584 if (defined $self->{notFoundException}) {
12585 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
12586 $xfer += $self->{notFoundException}->write($output);
12587 $xfer += $output->writeFieldEnd();
12588 }
12589 if (defined $self->{systemException}) {
12590 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
12591 $xfer += $self->{systemException}->write($output);
12592 $xfer += $output->writeFieldEnd();
12593 }
12594 $xfer += $output->writeFieldStop();
12595 $xfer += $output->writeStructEnd();
12596 return $xfer;
12597 }
12598  
12599 package Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args;
12600 use base qw(Class::Accessor);
12601 Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->mk_accessors( qw( authenticationToken sharedNotebookIds ) );
12602  
12603 sub new {
12604 my $classname = shift;
12605 my $self = {};
12606 my $vals = shift || {};
12607 $self->{authenticationToken} = undef;
12608 $self->{sharedNotebookIds} = undef;
12609 if (UNIVERSAL::isa($vals,'HASH')) {
12610 if (defined $vals->{authenticationToken}) {
12611 $self->{authenticationToken} = $vals->{authenticationToken};
12612 }
12613 if (defined $vals->{sharedNotebookIds}) {
12614 $self->{sharedNotebookIds} = $vals->{sharedNotebookIds};
12615 }
12616 }
12617 return bless ($self, $classname);
12618 }
12619  
12620 sub getName {
12621 return 'NoteStore_expungeSharedNotebooks_args';
12622 }
12623  
12624 sub read {
12625 my ($self, $input) = @_;
12626 my $xfer = 0;
12627 my $fname;
12628 my $ftype = 0;
12629 my $fid = 0;
12630 $xfer += $input->readStructBegin(\$fname);
12631 while (1)
12632 {
12633 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12634 if ($ftype == TType::STOP) {
12635 last;
12636 }
12637 SWITCH: for($fid)
12638 {
12639 /^1$/ && do{ if ($ftype == TType::STRING) {
12640 $xfer += $input->readString(\$self->{authenticationToken});
12641 } else {
12642 $xfer += $input->skip($ftype);
12643 }
12644 last; };
12645 /^2$/ && do{ if ($ftype == TType::LIST) {
12646 {
12647 my $_size251 = 0;
12648 $self->{sharedNotebookIds} = [];
12649 my $_etype254 = 0;
12650 $xfer += $input->readListBegin(\$_etype254, \$_size251);
12651 for (my $_i255 = 0; $_i255 < $_size251; ++$_i255)
12652 {
12653 my $elem256 = undef;
12654 $xfer += $input->readI64(\$elem256);
12655 push(@{$self->{sharedNotebookIds}},$elem256);
12656 }
12657 $xfer += $input->readListEnd();
12658 }
12659 } else {
12660 $xfer += $input->skip($ftype);
12661 }
12662 last; };
12663 $xfer += $input->skip($ftype);
12664 }
12665 $xfer += $input->readFieldEnd();
12666 }
12667 $xfer += $input->readStructEnd();
12668 return $xfer;
12669 }
12670  
12671 sub write {
12672 my ($self, $output) = @_;
12673 my $xfer = 0;
12674 $xfer += $output->writeStructBegin('NoteStore_expungeSharedNotebooks_args');
12675 if (defined $self->{authenticationToken}) {
12676 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
12677 $xfer += $output->writeString($self->{authenticationToken});
12678 $xfer += $output->writeFieldEnd();
12679 }
12680 if (defined $self->{sharedNotebookIds}) {
12681 $xfer += $output->writeFieldBegin('sharedNotebookIds', TType::LIST, 2);
12682 {
12683 $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{sharedNotebookIds}}));
12684 {
12685 foreach my $iter257 (@{$self->{sharedNotebookIds}})
12686 {
12687 $xfer += $output->writeI64($iter257);
12688 }
12689 }
12690 $xfer += $output->writeListEnd();
12691 }
12692 $xfer += $output->writeFieldEnd();
12693 }
12694 $xfer += $output->writeFieldStop();
12695 $xfer += $output->writeStructEnd();
12696 return $xfer;
12697 }
12698  
12699 package Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result;
12700 use base qw(Class::Accessor);
12701 Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->mk_accessors( qw( success ) );
12702  
12703 sub new {
12704 my $classname = shift;
12705 my $self = {};
12706 my $vals = shift || {};
12707 $self->{success} = undef;
12708 $self->{userException} = undef;
12709 $self->{notFoundException} = undef;
12710 $self->{systemException} = undef;
12711 if (UNIVERSAL::isa($vals,'HASH')) {
12712 if (defined $vals->{success}) {
12713 $self->{success} = $vals->{success};
12714 }
12715 if (defined $vals->{userException}) {
12716 $self->{userException} = $vals->{userException};
12717 }
12718 if (defined $vals->{notFoundException}) {
12719 $self->{notFoundException} = $vals->{notFoundException};
12720 }
12721 if (defined $vals->{systemException}) {
12722 $self->{systemException} = $vals->{systemException};
12723 }
12724 }
12725 return bless ($self, $classname);
12726 }
12727  
12728 sub getName {
12729 return 'NoteStore_expungeSharedNotebooks_result';
12730 }
12731  
12732 sub read {
12733 my ($self, $input) = @_;
12734 my $xfer = 0;
12735 my $fname;
12736 my $ftype = 0;
12737 my $fid = 0;
12738 $xfer += $input->readStructBegin(\$fname);
12739 while (1)
12740 {
12741 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12742 if ($ftype == TType::STOP) {
12743 last;
12744 }
12745 SWITCH: for($fid)
12746 {
12747 /^0$/ && do{ if ($ftype == TType::I32) {
12748 $xfer += $input->readI32(\$self->{success});
12749 } else {
12750 $xfer += $input->skip($ftype);
12751 }
12752 last; };
12753 /^1$/ && do{ if ($ftype == TType::STRUCT) {
12754 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
12755 $xfer += $self->{userException}->read($input);
12756 } else {
12757 $xfer += $input->skip($ftype);
12758 }
12759 last; };
12760 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12761 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
12762 $xfer += $self->{notFoundException}->read($input);
12763 } else {
12764 $xfer += $input->skip($ftype);
12765 }
12766 last; };
12767 /^3$/ && do{ if ($ftype == TType::STRUCT) {
12768 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
12769 $xfer += $self->{systemException}->read($input);
12770 } else {
12771 $xfer += $input->skip($ftype);
12772 }
12773 last; };
12774 $xfer += $input->skip($ftype);
12775 }
12776 $xfer += $input->readFieldEnd();
12777 }
12778 $xfer += $input->readStructEnd();
12779 return $xfer;
12780 }
12781  
12782 sub write {
12783 my ($self, $output) = @_;
12784 my $xfer = 0;
12785 $xfer += $output->writeStructBegin('NoteStore_expungeSharedNotebooks_result');
12786 if (defined $self->{success}) {
12787 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
12788 $xfer += $output->writeI32($self->{success});
12789 $xfer += $output->writeFieldEnd();
12790 }
12791 if (defined $self->{userException}) {
12792 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
12793 $xfer += $self->{userException}->write($output);
12794 $xfer += $output->writeFieldEnd();
12795 }
12796 if (defined $self->{notFoundException}) {
12797 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
12798 $xfer += $self->{notFoundException}->write($output);
12799 $xfer += $output->writeFieldEnd();
12800 }
12801 if (defined $self->{systemException}) {
12802 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
12803 $xfer += $self->{systemException}->write($output);
12804 $xfer += $output->writeFieldEnd();
12805 }
12806 $xfer += $output->writeFieldStop();
12807 $xfer += $output->writeStructEnd();
12808 return $xfer;
12809 }
12810  
12811 package Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args;
12812 use base qw(Class::Accessor);
12813 Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->mk_accessors( qw( authenticationToken linkedNotebook ) );
12814  
12815 sub new {
12816 my $classname = shift;
12817 my $self = {};
12818 my $vals = shift || {};
12819 $self->{authenticationToken} = undef;
12820 $self->{linkedNotebook} = undef;
12821 if (UNIVERSAL::isa($vals,'HASH')) {
12822 if (defined $vals->{authenticationToken}) {
12823 $self->{authenticationToken} = $vals->{authenticationToken};
12824 }
12825 if (defined $vals->{linkedNotebook}) {
12826 $self->{linkedNotebook} = $vals->{linkedNotebook};
12827 }
12828 }
12829 return bless ($self, $classname);
12830 }
12831  
12832 sub getName {
12833 return 'NoteStore_createLinkedNotebook_args';
12834 }
12835  
12836 sub read {
12837 my ($self, $input) = @_;
12838 my $xfer = 0;
12839 my $fname;
12840 my $ftype = 0;
12841 my $fid = 0;
12842 $xfer += $input->readStructBegin(\$fname);
12843 while (1)
12844 {
12845 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12846 if ($ftype == TType::STOP) {
12847 last;
12848 }
12849 SWITCH: for($fid)
12850 {
12851 /^1$/ && do{ if ($ftype == TType::STRING) {
12852 $xfer += $input->readString(\$self->{authenticationToken});
12853 } else {
12854 $xfer += $input->skip($ftype);
12855 }
12856 last; };
12857 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12858 $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
12859 $xfer += $self->{linkedNotebook}->read($input);
12860 } else {
12861 $xfer += $input->skip($ftype);
12862 }
12863 last; };
12864 $xfer += $input->skip($ftype);
12865 }
12866 $xfer += $input->readFieldEnd();
12867 }
12868 $xfer += $input->readStructEnd();
12869 return $xfer;
12870 }
12871  
12872 sub write {
12873 my ($self, $output) = @_;
12874 my $xfer = 0;
12875 $xfer += $output->writeStructBegin('NoteStore_createLinkedNotebook_args');
12876 if (defined $self->{authenticationToken}) {
12877 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
12878 $xfer += $output->writeString($self->{authenticationToken});
12879 $xfer += $output->writeFieldEnd();
12880 }
12881 if (defined $self->{linkedNotebook}) {
12882 $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
12883 $xfer += $self->{linkedNotebook}->write($output);
12884 $xfer += $output->writeFieldEnd();
12885 }
12886 $xfer += $output->writeFieldStop();
12887 $xfer += $output->writeStructEnd();
12888 return $xfer;
12889 }
12890  
12891 package Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result;
12892 use base qw(Class::Accessor);
12893 Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->mk_accessors( qw( success ) );
12894  
12895 sub new {
12896 my $classname = shift;
12897 my $self = {};
12898 my $vals = shift || {};
12899 $self->{success} = undef;
12900 $self->{userException} = undef;
12901 $self->{notFoundException} = undef;
12902 $self->{systemException} = undef;
12903 if (UNIVERSAL::isa($vals,'HASH')) {
12904 if (defined $vals->{success}) {
12905 $self->{success} = $vals->{success};
12906 }
12907 if (defined $vals->{userException}) {
12908 $self->{userException} = $vals->{userException};
12909 }
12910 if (defined $vals->{notFoundException}) {
12911 $self->{notFoundException} = $vals->{notFoundException};
12912 }
12913 if (defined $vals->{systemException}) {
12914 $self->{systemException} = $vals->{systemException};
12915 }
12916 }
12917 return bless ($self, $classname);
12918 }
12919  
12920 sub getName {
12921 return 'NoteStore_createLinkedNotebook_result';
12922 }
12923  
12924 sub read {
12925 my ($self, $input) = @_;
12926 my $xfer = 0;
12927 my $fname;
12928 my $ftype = 0;
12929 my $fid = 0;
12930 $xfer += $input->readStructBegin(\$fname);
12931 while (1)
12932 {
12933 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
12934 if ($ftype == TType::STOP) {
12935 last;
12936 }
12937 SWITCH: for($fid)
12938 {
12939 /^0$/ && do{ if ($ftype == TType::STRUCT) {
12940 $self->{success} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
12941 $xfer += $self->{success}->read($input);
12942 } else {
12943 $xfer += $input->skip($ftype);
12944 }
12945 last; };
12946 /^1$/ && do{ if ($ftype == TType::STRUCT) {
12947 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
12948 $xfer += $self->{userException}->read($input);
12949 } else {
12950 $xfer += $input->skip($ftype);
12951 }
12952 last; };
12953 /^2$/ && do{ if ($ftype == TType::STRUCT) {
12954 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
12955 $xfer += $self->{notFoundException}->read($input);
12956 } else {
12957 $xfer += $input->skip($ftype);
12958 }
12959 last; };
12960 /^3$/ && do{ if ($ftype == TType::STRUCT) {
12961 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
12962 $xfer += $self->{systemException}->read($input);
12963 } else {
12964 $xfer += $input->skip($ftype);
12965 }
12966 last; };
12967 $xfer += $input->skip($ftype);
12968 }
12969 $xfer += $input->readFieldEnd();
12970 }
12971 $xfer += $input->readStructEnd();
12972 return $xfer;
12973 }
12974  
12975 sub write {
12976 my ($self, $output) = @_;
12977 my $xfer = 0;
12978 $xfer += $output->writeStructBegin('NoteStore_createLinkedNotebook_result');
12979 if (defined $self->{success}) {
12980 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
12981 $xfer += $self->{success}->write($output);
12982 $xfer += $output->writeFieldEnd();
12983 }
12984 if (defined $self->{userException}) {
12985 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
12986 $xfer += $self->{userException}->write($output);
12987 $xfer += $output->writeFieldEnd();
12988 }
12989 if (defined $self->{notFoundException}) {
12990 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
12991 $xfer += $self->{notFoundException}->write($output);
12992 $xfer += $output->writeFieldEnd();
12993 }
12994 if (defined $self->{systemException}) {
12995 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
12996 $xfer += $self->{systemException}->write($output);
12997 $xfer += $output->writeFieldEnd();
12998 }
12999 $xfer += $output->writeFieldStop();
13000 $xfer += $output->writeStructEnd();
13001 return $xfer;
13002 }
13003  
13004 package Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args;
13005 use base qw(Class::Accessor);
13006 Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->mk_accessors( qw( authenticationToken linkedNotebook ) );
13007  
13008 sub new {
13009 my $classname = shift;
13010 my $self = {};
13011 my $vals = shift || {};
13012 $self->{authenticationToken} = undef;
13013 $self->{linkedNotebook} = undef;
13014 if (UNIVERSAL::isa($vals,'HASH')) {
13015 if (defined $vals->{authenticationToken}) {
13016 $self->{authenticationToken} = $vals->{authenticationToken};
13017 }
13018 if (defined $vals->{linkedNotebook}) {
13019 $self->{linkedNotebook} = $vals->{linkedNotebook};
13020 }
13021 }
13022 return bless ($self, $classname);
13023 }
13024  
13025 sub getName {
13026 return 'NoteStore_updateLinkedNotebook_args';
13027 }
13028  
13029 sub read {
13030 my ($self, $input) = @_;
13031 my $xfer = 0;
13032 my $fname;
13033 my $ftype = 0;
13034 my $fid = 0;
13035 $xfer += $input->readStructBegin(\$fname);
13036 while (1)
13037 {
13038 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13039 if ($ftype == TType::STOP) {
13040 last;
13041 }
13042 SWITCH: for($fid)
13043 {
13044 /^1$/ && do{ if ($ftype == TType::STRING) {
13045 $xfer += $input->readString(\$self->{authenticationToken});
13046 } else {
13047 $xfer += $input->skip($ftype);
13048 }
13049 last; };
13050 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13051 $self->{linkedNotebook} = Net::Evernote::EDAMTypes::LinkedNotebook->new();
13052 $xfer += $self->{linkedNotebook}->read($input);
13053 } else {
13054 $xfer += $input->skip($ftype);
13055 }
13056 last; };
13057 $xfer += $input->skip($ftype);
13058 }
13059 $xfer += $input->readFieldEnd();
13060 }
13061 $xfer += $input->readStructEnd();
13062 return $xfer;
13063 }
13064  
13065 sub write {
13066 my ($self, $output) = @_;
13067 my $xfer = 0;
13068 $xfer += $output->writeStructBegin('NoteStore_updateLinkedNotebook_args');
13069 if (defined $self->{authenticationToken}) {
13070 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
13071 $xfer += $output->writeString($self->{authenticationToken});
13072 $xfer += $output->writeFieldEnd();
13073 }
13074 if (defined $self->{linkedNotebook}) {
13075 $xfer += $output->writeFieldBegin('linkedNotebook', TType::STRUCT, 2);
13076 $xfer += $self->{linkedNotebook}->write($output);
13077 $xfer += $output->writeFieldEnd();
13078 }
13079 $xfer += $output->writeFieldStop();
13080 $xfer += $output->writeStructEnd();
13081 return $xfer;
13082 }
13083  
13084 package Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result;
13085 use base qw(Class::Accessor);
13086 Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->mk_accessors( qw( success ) );
13087  
13088 sub new {
13089 my $classname = shift;
13090 my $self = {};
13091 my $vals = shift || {};
13092 $self->{success} = undef;
13093 $self->{userException} = undef;
13094 $self->{notFoundException} = undef;
13095 $self->{systemException} = undef;
13096 if (UNIVERSAL::isa($vals,'HASH')) {
13097 if (defined $vals->{success}) {
13098 $self->{success} = $vals->{success};
13099 }
13100 if (defined $vals->{userException}) {
13101 $self->{userException} = $vals->{userException};
13102 }
13103 if (defined $vals->{notFoundException}) {
13104 $self->{notFoundException} = $vals->{notFoundException};
13105 }
13106 if (defined $vals->{systemException}) {
13107 $self->{systemException} = $vals->{systemException};
13108 }
13109 }
13110 return bless ($self, $classname);
13111 }
13112  
13113 sub getName {
13114 return 'NoteStore_updateLinkedNotebook_result';
13115 }
13116  
13117 sub read {
13118 my ($self, $input) = @_;
13119 my $xfer = 0;
13120 my $fname;
13121 my $ftype = 0;
13122 my $fid = 0;
13123 $xfer += $input->readStructBegin(\$fname);
13124 while (1)
13125 {
13126 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13127 if ($ftype == TType::STOP) {
13128 last;
13129 }
13130 SWITCH: for($fid)
13131 {
13132 /^0$/ && do{ if ($ftype == TType::I32) {
13133 $xfer += $input->readI32(\$self->{success});
13134 } else {
13135 $xfer += $input->skip($ftype);
13136 }
13137 last; };
13138 /^1$/ && do{ if ($ftype == TType::STRUCT) {
13139 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
13140 $xfer += $self->{userException}->read($input);
13141 } else {
13142 $xfer += $input->skip($ftype);
13143 }
13144 last; };
13145 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13146 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
13147 $xfer += $self->{notFoundException}->read($input);
13148 } else {
13149 $xfer += $input->skip($ftype);
13150 }
13151 last; };
13152 /^3$/ && do{ if ($ftype == TType::STRUCT) {
13153 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
13154 $xfer += $self->{systemException}->read($input);
13155 } else {
13156 $xfer += $input->skip($ftype);
13157 }
13158 last; };
13159 $xfer += $input->skip($ftype);
13160 }
13161 $xfer += $input->readFieldEnd();
13162 }
13163 $xfer += $input->readStructEnd();
13164 return $xfer;
13165 }
13166  
13167 sub write {
13168 my ($self, $output) = @_;
13169 my $xfer = 0;
13170 $xfer += $output->writeStructBegin('NoteStore_updateLinkedNotebook_result');
13171 if (defined $self->{success}) {
13172 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
13173 $xfer += $output->writeI32($self->{success});
13174 $xfer += $output->writeFieldEnd();
13175 }
13176 if (defined $self->{userException}) {
13177 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
13178 $xfer += $self->{userException}->write($output);
13179 $xfer += $output->writeFieldEnd();
13180 }
13181 if (defined $self->{notFoundException}) {
13182 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
13183 $xfer += $self->{notFoundException}->write($output);
13184 $xfer += $output->writeFieldEnd();
13185 }
13186 if (defined $self->{systemException}) {
13187 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
13188 $xfer += $self->{systemException}->write($output);
13189 $xfer += $output->writeFieldEnd();
13190 }
13191 $xfer += $output->writeFieldStop();
13192 $xfer += $output->writeStructEnd();
13193 return $xfer;
13194 }
13195  
13196 package Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args;
13197 use base qw(Class::Accessor);
13198 Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->mk_accessors( qw( authenticationToken ) );
13199  
13200 sub new {
13201 my $classname = shift;
13202 my $self = {};
13203 my $vals = shift || {};
13204 $self->{authenticationToken} = undef;
13205 if (UNIVERSAL::isa($vals,'HASH')) {
13206 if (defined $vals->{authenticationToken}) {
13207 $self->{authenticationToken} = $vals->{authenticationToken};
13208 }
13209 }
13210 return bless ($self, $classname);
13211 }
13212  
13213 sub getName {
13214 return 'NoteStore_listLinkedNotebooks_args';
13215 }
13216  
13217 sub read {
13218 my ($self, $input) = @_;
13219 my $xfer = 0;
13220 my $fname;
13221 my $ftype = 0;
13222 my $fid = 0;
13223 $xfer += $input->readStructBegin(\$fname);
13224 while (1)
13225 {
13226 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13227 if ($ftype == TType::STOP) {
13228 last;
13229 }
13230 SWITCH: for($fid)
13231 {
13232 /^1$/ && do{ if ($ftype == TType::STRING) {
13233 $xfer += $input->readString(\$self->{authenticationToken});
13234 } else {
13235 $xfer += $input->skip($ftype);
13236 }
13237 last; };
13238 $xfer += $input->skip($ftype);
13239 }
13240 $xfer += $input->readFieldEnd();
13241 }
13242 $xfer += $input->readStructEnd();
13243 return $xfer;
13244 }
13245  
13246 sub write {
13247 my ($self, $output) = @_;
13248 my $xfer = 0;
13249 $xfer += $output->writeStructBegin('NoteStore_listLinkedNotebooks_args');
13250 if (defined $self->{authenticationToken}) {
13251 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
13252 $xfer += $output->writeString($self->{authenticationToken});
13253 $xfer += $output->writeFieldEnd();
13254 }
13255 $xfer += $output->writeFieldStop();
13256 $xfer += $output->writeStructEnd();
13257 return $xfer;
13258 }
13259  
13260 package Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result;
13261 use base qw(Class::Accessor);
13262 Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->mk_accessors( qw( success ) );
13263  
13264 sub new {
13265 my $classname = shift;
13266 my $self = {};
13267 my $vals = shift || {};
13268 $self->{success} = undef;
13269 $self->{userException} = undef;
13270 $self->{notFoundException} = undef;
13271 $self->{systemException} = undef;
13272 if (UNIVERSAL::isa($vals,'HASH')) {
13273 if (defined $vals->{success}) {
13274 $self->{success} = $vals->{success};
13275 }
13276 if (defined $vals->{userException}) {
13277 $self->{userException} = $vals->{userException};
13278 }
13279 if (defined $vals->{notFoundException}) {
13280 $self->{notFoundException} = $vals->{notFoundException};
13281 }
13282 if (defined $vals->{systemException}) {
13283 $self->{systemException} = $vals->{systemException};
13284 }
13285 }
13286 return bless ($self, $classname);
13287 }
13288  
13289 sub getName {
13290 return 'NoteStore_listLinkedNotebooks_result';
13291 }
13292  
13293 sub read {
13294 my ($self, $input) = @_;
13295 my $xfer = 0;
13296 my $fname;
13297 my $ftype = 0;
13298 my $fid = 0;
13299 $xfer += $input->readStructBegin(\$fname);
13300 while (1)
13301 {
13302 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13303 if ($ftype == TType::STOP) {
13304 last;
13305 }
13306 SWITCH: for($fid)
13307 {
13308 /^0$/ && do{ if ($ftype == TType::LIST) {
13309 {
13310 my $_size258 = 0;
13311 $self->{success} = [];
13312 my $_etype261 = 0;
13313 $xfer += $input->readListBegin(\$_etype261, \$_size258);
13314 for (my $_i262 = 0; $_i262 < $_size258; ++$_i262)
13315 {
13316 my $elem263 = undef;
13317 $elem263 = Net::Evernote::EDAMTypes::LinkedNotebook->new();
13318 $xfer += $elem263->read($input);
13319 push(@{$self->{success}},$elem263);
13320 }
13321 $xfer += $input->readListEnd();
13322 }
13323 } else {
13324 $xfer += $input->skip($ftype);
13325 }
13326 last; };
13327 /^1$/ && do{ if ($ftype == TType::STRUCT) {
13328 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
13329 $xfer += $self->{userException}->read($input);
13330 } else {
13331 $xfer += $input->skip($ftype);
13332 }
13333 last; };
13334 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13335 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
13336 $xfer += $self->{notFoundException}->read($input);
13337 } else {
13338 $xfer += $input->skip($ftype);
13339 }
13340 last; };
13341 /^3$/ && do{ if ($ftype == TType::STRUCT) {
13342 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
13343 $xfer += $self->{systemException}->read($input);
13344 } else {
13345 $xfer += $input->skip($ftype);
13346 }
13347 last; };
13348 $xfer += $input->skip($ftype);
13349 }
13350 $xfer += $input->readFieldEnd();
13351 }
13352 $xfer += $input->readStructEnd();
13353 return $xfer;
13354 }
13355  
13356 sub write {
13357 my ($self, $output) = @_;
13358 my $xfer = 0;
13359 $xfer += $output->writeStructBegin('NoteStore_listLinkedNotebooks_result');
13360 if (defined $self->{success}) {
13361 $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
13362 {
13363 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
13364 {
13365 foreach my $iter264 (@{$self->{success}})
13366 {
13367 $xfer += ${iter264}->write($output);
13368 }
13369 }
13370 $xfer += $output->writeListEnd();
13371 }
13372 $xfer += $output->writeFieldEnd();
13373 }
13374 if (defined $self->{userException}) {
13375 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
13376 $xfer += $self->{userException}->write($output);
13377 $xfer += $output->writeFieldEnd();
13378 }
13379 if (defined $self->{notFoundException}) {
13380 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
13381 $xfer += $self->{notFoundException}->write($output);
13382 $xfer += $output->writeFieldEnd();
13383 }
13384 if (defined $self->{systemException}) {
13385 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
13386 $xfer += $self->{systemException}->write($output);
13387 $xfer += $output->writeFieldEnd();
13388 }
13389 $xfer += $output->writeFieldStop();
13390 $xfer += $output->writeStructEnd();
13391 return $xfer;
13392 }
13393  
13394 package Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args;
13395 use base qw(Class::Accessor);
13396 Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->mk_accessors( qw( authenticationToken guid ) );
13397  
13398 sub new {
13399 my $classname = shift;
13400 my $self = {};
13401 my $vals = shift || {};
13402 $self->{authenticationToken} = undef;
13403 $self->{guid} = undef;
13404 if (UNIVERSAL::isa($vals,'HASH')) {
13405 if (defined $vals->{authenticationToken}) {
13406 $self->{authenticationToken} = $vals->{authenticationToken};
13407 }
13408 if (defined $vals->{guid}) {
13409 $self->{guid} = $vals->{guid};
13410 }
13411 }
13412 return bless ($self, $classname);
13413 }
13414  
13415 sub getName {
13416 return 'NoteStore_expungeLinkedNotebook_args';
13417 }
13418  
13419 sub read {
13420 my ($self, $input) = @_;
13421 my $xfer = 0;
13422 my $fname;
13423 my $ftype = 0;
13424 my $fid = 0;
13425 $xfer += $input->readStructBegin(\$fname);
13426 while (1)
13427 {
13428 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13429 if ($ftype == TType::STOP) {
13430 last;
13431 }
13432 SWITCH: for($fid)
13433 {
13434 /^1$/ && do{ if ($ftype == TType::STRING) {
13435 $xfer += $input->readString(\$self->{authenticationToken});
13436 } else {
13437 $xfer += $input->skip($ftype);
13438 }
13439 last; };
13440 /^2$/ && do{ if ($ftype == TType::STRING) {
13441 $xfer += $input->readString(\$self->{guid});
13442 } else {
13443 $xfer += $input->skip($ftype);
13444 }
13445 last; };
13446 $xfer += $input->skip($ftype);
13447 }
13448 $xfer += $input->readFieldEnd();
13449 }
13450 $xfer += $input->readStructEnd();
13451 return $xfer;
13452 }
13453  
13454 sub write {
13455 my ($self, $output) = @_;
13456 my $xfer = 0;
13457 $xfer += $output->writeStructBegin('NoteStore_expungeLinkedNotebook_args');
13458 if (defined $self->{authenticationToken}) {
13459 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
13460 $xfer += $output->writeString($self->{authenticationToken});
13461 $xfer += $output->writeFieldEnd();
13462 }
13463 if (defined $self->{guid}) {
13464 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
13465 $xfer += $output->writeString($self->{guid});
13466 $xfer += $output->writeFieldEnd();
13467 }
13468 $xfer += $output->writeFieldStop();
13469 $xfer += $output->writeStructEnd();
13470 return $xfer;
13471 }
13472  
13473 package Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result;
13474 use base qw(Class::Accessor);
13475 Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->mk_accessors( qw( success ) );
13476  
13477 sub new {
13478 my $classname = shift;
13479 my $self = {};
13480 my $vals = shift || {};
13481 $self->{success} = undef;
13482 $self->{userException} = undef;
13483 $self->{notFoundException} = undef;
13484 $self->{systemException} = undef;
13485 if (UNIVERSAL::isa($vals,'HASH')) {
13486 if (defined $vals->{success}) {
13487 $self->{success} = $vals->{success};
13488 }
13489 if (defined $vals->{userException}) {
13490 $self->{userException} = $vals->{userException};
13491 }
13492 if (defined $vals->{notFoundException}) {
13493 $self->{notFoundException} = $vals->{notFoundException};
13494 }
13495 if (defined $vals->{systemException}) {
13496 $self->{systemException} = $vals->{systemException};
13497 }
13498 }
13499 return bless ($self, $classname);
13500 }
13501  
13502 sub getName {
13503 return 'NoteStore_expungeLinkedNotebook_result';
13504 }
13505  
13506 sub read {
13507 my ($self, $input) = @_;
13508 my $xfer = 0;
13509 my $fname;
13510 my $ftype = 0;
13511 my $fid = 0;
13512 $xfer += $input->readStructBegin(\$fname);
13513 while (1)
13514 {
13515 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13516 if ($ftype == TType::STOP) {
13517 last;
13518 }
13519 SWITCH: for($fid)
13520 {
13521 /^0$/ && do{ if ($ftype == TType::I32) {
13522 $xfer += $input->readI32(\$self->{success});
13523 } else {
13524 $xfer += $input->skip($ftype);
13525 }
13526 last; };
13527 /^1$/ && do{ if ($ftype == TType::STRUCT) {
13528 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
13529 $xfer += $self->{userException}->read($input);
13530 } else {
13531 $xfer += $input->skip($ftype);
13532 }
13533 last; };
13534 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13535 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
13536 $xfer += $self->{notFoundException}->read($input);
13537 } else {
13538 $xfer += $input->skip($ftype);
13539 }
13540 last; };
13541 /^3$/ && do{ if ($ftype == TType::STRUCT) {
13542 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
13543 $xfer += $self->{systemException}->read($input);
13544 } else {
13545 $xfer += $input->skip($ftype);
13546 }
13547 last; };
13548 $xfer += $input->skip($ftype);
13549 }
13550 $xfer += $input->readFieldEnd();
13551 }
13552 $xfer += $input->readStructEnd();
13553 return $xfer;
13554 }
13555  
13556 sub write {
13557 my ($self, $output) = @_;
13558 my $xfer = 0;
13559 $xfer += $output->writeStructBegin('NoteStore_expungeLinkedNotebook_result');
13560 if (defined $self->{success}) {
13561 $xfer += $output->writeFieldBegin('success', TType::I32, 0);
13562 $xfer += $output->writeI32($self->{success});
13563 $xfer += $output->writeFieldEnd();
13564 }
13565 if (defined $self->{userException}) {
13566 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
13567 $xfer += $self->{userException}->write($output);
13568 $xfer += $output->writeFieldEnd();
13569 }
13570 if (defined $self->{notFoundException}) {
13571 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
13572 $xfer += $self->{notFoundException}->write($output);
13573 $xfer += $output->writeFieldEnd();
13574 }
13575 if (defined $self->{systemException}) {
13576 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
13577 $xfer += $self->{systemException}->write($output);
13578 $xfer += $output->writeFieldEnd();
13579 }
13580 $xfer += $output->writeFieldStop();
13581 $xfer += $output->writeStructEnd();
13582 return $xfer;
13583 }
13584  
13585 package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args;
13586 use base qw(Class::Accessor);
13587 Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->mk_accessors( qw( shareKey authenticationToken ) );
13588  
13589 sub new {
13590 my $classname = shift;
13591 my $self = {};
13592 my $vals = shift || {};
13593 $self->{shareKey} = undef;
13594 $self->{authenticationToken} = undef;
13595 if (UNIVERSAL::isa($vals,'HASH')) {
13596 if (defined $vals->{shareKey}) {
13597 $self->{shareKey} = $vals->{shareKey};
13598 }
13599 if (defined $vals->{authenticationToken}) {
13600 $self->{authenticationToken} = $vals->{authenticationToken};
13601 }
13602 }
13603 return bless ($self, $classname);
13604 }
13605  
13606 sub getName {
13607 return 'NoteStore_authenticateToSharedNotebook_args';
13608 }
13609  
13610 sub read {
13611 my ($self, $input) = @_;
13612 my $xfer = 0;
13613 my $fname;
13614 my $ftype = 0;
13615 my $fid = 0;
13616 $xfer += $input->readStructBegin(\$fname);
13617 while (1)
13618 {
13619 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13620 if ($ftype == TType::STOP) {
13621 last;
13622 }
13623 SWITCH: for($fid)
13624 {
13625 /^1$/ && do{ if ($ftype == TType::STRING) {
13626 $xfer += $input->readString(\$self->{shareKey});
13627 } else {
13628 $xfer += $input->skip($ftype);
13629 }
13630 last; };
13631 /^2$/ && do{ if ($ftype == TType::STRING) {
13632 $xfer += $input->readString(\$self->{authenticationToken});
13633 } else {
13634 $xfer += $input->skip($ftype);
13635 }
13636 last; };
13637 $xfer += $input->skip($ftype);
13638 }
13639 $xfer += $input->readFieldEnd();
13640 }
13641 $xfer += $input->readStructEnd();
13642 return $xfer;
13643 }
13644  
13645 sub write {
13646 my ($self, $output) = @_;
13647 my $xfer = 0;
13648 $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNotebook_args');
13649 if (defined $self->{shareKey}) {
13650 $xfer += $output->writeFieldBegin('shareKey', TType::STRING, 1);
13651 $xfer += $output->writeString($self->{shareKey});
13652 $xfer += $output->writeFieldEnd();
13653 }
13654 if (defined $self->{authenticationToken}) {
13655 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 2);
13656 $xfer += $output->writeString($self->{authenticationToken});
13657 $xfer += $output->writeFieldEnd();
13658 }
13659 $xfer += $output->writeFieldStop();
13660 $xfer += $output->writeStructEnd();
13661 return $xfer;
13662 }
13663  
13664 package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result;
13665 use base qw(Class::Accessor);
13666 Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->mk_accessors( qw( success ) );
13667  
13668 sub new {
13669 my $classname = shift;
13670 my $self = {};
13671 my $vals = shift || {};
13672 $self->{success} = undef;
13673 $self->{userException} = undef;
13674 $self->{notFoundException} = undef;
13675 $self->{systemException} = undef;
13676 if (UNIVERSAL::isa($vals,'HASH')) {
13677 if (defined $vals->{success}) {
13678 $self->{success} = $vals->{success};
13679 }
13680 if (defined $vals->{userException}) {
13681 $self->{userException} = $vals->{userException};
13682 }
13683 if (defined $vals->{notFoundException}) {
13684 $self->{notFoundException} = $vals->{notFoundException};
13685 }
13686 if (defined $vals->{systemException}) {
13687 $self->{systemException} = $vals->{systemException};
13688 }
13689 }
13690 return bless ($self, $classname);
13691 }
13692  
13693 sub getName {
13694 return 'NoteStore_authenticateToSharedNotebook_result';
13695 }
13696  
13697 sub read {
13698 my ($self, $input) = @_;
13699 my $xfer = 0;
13700 my $fname;
13701 my $ftype = 0;
13702 my $fid = 0;
13703 $xfer += $input->readStructBegin(\$fname);
13704 while (1)
13705 {
13706 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13707 if ($ftype == TType::STOP) {
13708 last;
13709 }
13710 SWITCH: for($fid)
13711 {
13712 /^0$/ && do{ if ($ftype == TType::STRUCT) {
13713 $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
13714 $xfer += $self->{success}->read($input);
13715 } else {
13716 $xfer += $input->skip($ftype);
13717 }
13718 last; };
13719 /^1$/ && do{ if ($ftype == TType::STRUCT) {
13720 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
13721 $xfer += $self->{userException}->read($input);
13722 } else {
13723 $xfer += $input->skip($ftype);
13724 }
13725 last; };
13726 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13727 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
13728 $xfer += $self->{notFoundException}->read($input);
13729 } else {
13730 $xfer += $input->skip($ftype);
13731 }
13732 last; };
13733 /^3$/ && do{ if ($ftype == TType::STRUCT) {
13734 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
13735 $xfer += $self->{systemException}->read($input);
13736 } else {
13737 $xfer += $input->skip($ftype);
13738 }
13739 last; };
13740 $xfer += $input->skip($ftype);
13741 }
13742 $xfer += $input->readFieldEnd();
13743 }
13744 $xfer += $input->readStructEnd();
13745 return $xfer;
13746 }
13747  
13748 sub write {
13749 my ($self, $output) = @_;
13750 my $xfer = 0;
13751 $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNotebook_result');
13752 if (defined $self->{success}) {
13753 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
13754 $xfer += $self->{success}->write($output);
13755 $xfer += $output->writeFieldEnd();
13756 }
13757 if (defined $self->{userException}) {
13758 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
13759 $xfer += $self->{userException}->write($output);
13760 $xfer += $output->writeFieldEnd();
13761 }
13762 if (defined $self->{notFoundException}) {
13763 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
13764 $xfer += $self->{notFoundException}->write($output);
13765 $xfer += $output->writeFieldEnd();
13766 }
13767 if (defined $self->{systemException}) {
13768 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
13769 $xfer += $self->{systemException}->write($output);
13770 $xfer += $output->writeFieldEnd();
13771 }
13772 $xfer += $output->writeFieldStop();
13773 $xfer += $output->writeStructEnd();
13774 return $xfer;
13775 }
13776  
13777 package Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args;
13778 use base qw(Class::Accessor);
13779 Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->mk_accessors( qw( authenticationToken ) );
13780  
13781 sub new {
13782 my $classname = shift;
13783 my $self = {};
13784 my $vals = shift || {};
13785 $self->{authenticationToken} = undef;
13786 if (UNIVERSAL::isa($vals,'HASH')) {
13787 if (defined $vals->{authenticationToken}) {
13788 $self->{authenticationToken} = $vals->{authenticationToken};
13789 }
13790 }
13791 return bless ($self, $classname);
13792 }
13793  
13794 sub getName {
13795 return 'NoteStore_getSharedNotebookByAuth_args';
13796 }
13797  
13798 sub read {
13799 my ($self, $input) = @_;
13800 my $xfer = 0;
13801 my $fname;
13802 my $ftype = 0;
13803 my $fid = 0;
13804 $xfer += $input->readStructBegin(\$fname);
13805 while (1)
13806 {
13807 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13808 if ($ftype == TType::STOP) {
13809 last;
13810 }
13811 SWITCH: for($fid)
13812 {
13813 /^1$/ && do{ if ($ftype == TType::STRING) {
13814 $xfer += $input->readString(\$self->{authenticationToken});
13815 } else {
13816 $xfer += $input->skip($ftype);
13817 }
13818 last; };
13819 $xfer += $input->skip($ftype);
13820 }
13821 $xfer += $input->readFieldEnd();
13822 }
13823 $xfer += $input->readStructEnd();
13824 return $xfer;
13825 }
13826  
13827 sub write {
13828 my ($self, $output) = @_;
13829 my $xfer = 0;
13830 $xfer += $output->writeStructBegin('NoteStore_getSharedNotebookByAuth_args');
13831 if (defined $self->{authenticationToken}) {
13832 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
13833 $xfer += $output->writeString($self->{authenticationToken});
13834 $xfer += $output->writeFieldEnd();
13835 }
13836 $xfer += $output->writeFieldStop();
13837 $xfer += $output->writeStructEnd();
13838 return $xfer;
13839 }
13840  
13841 package Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result;
13842 use base qw(Class::Accessor);
13843 Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->mk_accessors( qw( success ) );
13844  
13845 sub new {
13846 my $classname = shift;
13847 my $self = {};
13848 my $vals = shift || {};
13849 $self->{success} = undef;
13850 $self->{userException} = undef;
13851 $self->{notFoundException} = undef;
13852 $self->{systemException} = undef;
13853 if (UNIVERSAL::isa($vals,'HASH')) {
13854 if (defined $vals->{success}) {
13855 $self->{success} = $vals->{success};
13856 }
13857 if (defined $vals->{userException}) {
13858 $self->{userException} = $vals->{userException};
13859 }
13860 if (defined $vals->{notFoundException}) {
13861 $self->{notFoundException} = $vals->{notFoundException};
13862 }
13863 if (defined $vals->{systemException}) {
13864 $self->{systemException} = $vals->{systemException};
13865 }
13866 }
13867 return bless ($self, $classname);
13868 }
13869  
13870 sub getName {
13871 return 'NoteStore_getSharedNotebookByAuth_result';
13872 }
13873  
13874 sub read {
13875 my ($self, $input) = @_;
13876 my $xfer = 0;
13877 my $fname;
13878 my $ftype = 0;
13879 my $fid = 0;
13880 $xfer += $input->readStructBegin(\$fname);
13881 while (1)
13882 {
13883 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13884 if ($ftype == TType::STOP) {
13885 last;
13886 }
13887 SWITCH: for($fid)
13888 {
13889 /^0$/ && do{ if ($ftype == TType::STRUCT) {
13890 $self->{success} = Net::Evernote::EDAMTypes::SharedNotebook->new();
13891 $xfer += $self->{success}->read($input);
13892 } else {
13893 $xfer += $input->skip($ftype);
13894 }
13895 last; };
13896 /^1$/ && do{ if ($ftype == TType::STRUCT) {
13897 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
13898 $xfer += $self->{userException}->read($input);
13899 } else {
13900 $xfer += $input->skip($ftype);
13901 }
13902 last; };
13903 /^2$/ && do{ if ($ftype == TType::STRUCT) {
13904 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
13905 $xfer += $self->{notFoundException}->read($input);
13906 } else {
13907 $xfer += $input->skip($ftype);
13908 }
13909 last; };
13910 /^3$/ && do{ if ($ftype == TType::STRUCT) {
13911 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
13912 $xfer += $self->{systemException}->read($input);
13913 } else {
13914 $xfer += $input->skip($ftype);
13915 }
13916 last; };
13917 $xfer += $input->skip($ftype);
13918 }
13919 $xfer += $input->readFieldEnd();
13920 }
13921 $xfer += $input->readStructEnd();
13922 return $xfer;
13923 }
13924  
13925 sub write {
13926 my ($self, $output) = @_;
13927 my $xfer = 0;
13928 $xfer += $output->writeStructBegin('NoteStore_getSharedNotebookByAuth_result');
13929 if (defined $self->{success}) {
13930 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
13931 $xfer += $self->{success}->write($output);
13932 $xfer += $output->writeFieldEnd();
13933 }
13934 if (defined $self->{userException}) {
13935 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
13936 $xfer += $self->{userException}->write($output);
13937 $xfer += $output->writeFieldEnd();
13938 }
13939 if (defined $self->{notFoundException}) {
13940 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
13941 $xfer += $self->{notFoundException}->write($output);
13942 $xfer += $output->writeFieldEnd();
13943 }
13944 if (defined $self->{systemException}) {
13945 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
13946 $xfer += $self->{systemException}->write($output);
13947 $xfer += $output->writeFieldEnd();
13948 }
13949 $xfer += $output->writeFieldStop();
13950 $xfer += $output->writeStructEnd();
13951 return $xfer;
13952 }
13953  
13954 package Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args;
13955 use base qw(Class::Accessor);
13956 Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->mk_accessors( qw( authenticationToken parameters ) );
13957  
13958 sub new {
13959 my $classname = shift;
13960 my $self = {};
13961 my $vals = shift || {};
13962 $self->{authenticationToken} = undef;
13963 $self->{parameters} = undef;
13964 if (UNIVERSAL::isa($vals,'HASH')) {
13965 if (defined $vals->{authenticationToken}) {
13966 $self->{authenticationToken} = $vals->{authenticationToken};
13967 }
13968 if (defined $vals->{parameters}) {
13969 $self->{parameters} = $vals->{parameters};
13970 }
13971 }
13972 return bless ($self, $classname);
13973 }
13974  
13975 sub getName {
13976 return 'NoteStore_emailNote_args';
13977 }
13978  
13979 sub read {
13980 my ($self, $input) = @_;
13981 my $xfer = 0;
13982 my $fname;
13983 my $ftype = 0;
13984 my $fid = 0;
13985 $xfer += $input->readStructBegin(\$fname);
13986 while (1)
13987 {
13988 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
13989 if ($ftype == TType::STOP) {
13990 last;
13991 }
13992 SWITCH: for($fid)
13993 {
13994 /^1$/ && do{ if ($ftype == TType::STRING) {
13995 $xfer += $input->readString(\$self->{authenticationToken});
13996 } else {
13997 $xfer += $input->skip($ftype);
13998 }
13999 last; };
14000 /^2$/ && do{ if ($ftype == TType::STRUCT) {
14001 $self->{parameters} = Net::Evernote::EDAMNoteStore::NoteEmailParameters->new();
14002 $xfer += $self->{parameters}->read($input);
14003 } else {
14004 $xfer += $input->skip($ftype);
14005 }
14006 last; };
14007 $xfer += $input->skip($ftype);
14008 }
14009 $xfer += $input->readFieldEnd();
14010 }
14011 $xfer += $input->readStructEnd();
14012 return $xfer;
14013 }
14014  
14015 sub write {
14016 my ($self, $output) = @_;
14017 my $xfer = 0;
14018 $xfer += $output->writeStructBegin('NoteStore_emailNote_args');
14019 if (defined $self->{authenticationToken}) {
14020 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
14021 $xfer += $output->writeString($self->{authenticationToken});
14022 $xfer += $output->writeFieldEnd();
14023 }
14024 if (defined $self->{parameters}) {
14025 $xfer += $output->writeFieldBegin('parameters', TType::STRUCT, 2);
14026 $xfer += $self->{parameters}->write($output);
14027 $xfer += $output->writeFieldEnd();
14028 }
14029 $xfer += $output->writeFieldStop();
14030 $xfer += $output->writeStructEnd();
14031 return $xfer;
14032 }
14033  
14034 package Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result;
14035 use base qw(Class::Accessor);
14036 Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->mk_accessors( qw( ) );
14037  
14038 sub new {
14039 my $classname = shift;
14040 my $self = {};
14041 my $vals = shift || {};
14042 $self->{userException} = undef;
14043 $self->{notFoundException} = undef;
14044 $self->{systemException} = undef;
14045 if (UNIVERSAL::isa($vals,'HASH')) {
14046 if (defined $vals->{userException}) {
14047 $self->{userException} = $vals->{userException};
14048 }
14049 if (defined $vals->{notFoundException}) {
14050 $self->{notFoundException} = $vals->{notFoundException};
14051 }
14052 if (defined $vals->{systemException}) {
14053 $self->{systemException} = $vals->{systemException};
14054 }
14055 }
14056 return bless ($self, $classname);
14057 }
14058  
14059 sub getName {
14060 return 'NoteStore_emailNote_result';
14061 }
14062  
14063 sub read {
14064 my ($self, $input) = @_;
14065 my $xfer = 0;
14066 my $fname;
14067 my $ftype = 0;
14068 my $fid = 0;
14069 $xfer += $input->readStructBegin(\$fname);
14070 while (1)
14071 {
14072 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14073 if ($ftype == TType::STOP) {
14074 last;
14075 }
14076 SWITCH: for($fid)
14077 {
14078 /^1$/ && do{ if ($ftype == TType::STRUCT) {
14079 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
14080 $xfer += $self->{userException}->read($input);
14081 } else {
14082 $xfer += $input->skip($ftype);
14083 }
14084 last; };
14085 /^2$/ && do{ if ($ftype == TType::STRUCT) {
14086 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
14087 $xfer += $self->{notFoundException}->read($input);
14088 } else {
14089 $xfer += $input->skip($ftype);
14090 }
14091 last; };
14092 /^3$/ && do{ if ($ftype == TType::STRUCT) {
14093 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
14094 $xfer += $self->{systemException}->read($input);
14095 } else {
14096 $xfer += $input->skip($ftype);
14097 }
14098 last; };
14099 $xfer += $input->skip($ftype);
14100 }
14101 $xfer += $input->readFieldEnd();
14102 }
14103 $xfer += $input->readStructEnd();
14104 return $xfer;
14105 }
14106  
14107 sub write {
14108 my ($self, $output) = @_;
14109 my $xfer = 0;
14110 $xfer += $output->writeStructBegin('NoteStore_emailNote_result');
14111 if (defined $self->{userException}) {
14112 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
14113 $xfer += $self->{userException}->write($output);
14114 $xfer += $output->writeFieldEnd();
14115 }
14116 if (defined $self->{notFoundException}) {
14117 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
14118 $xfer += $self->{notFoundException}->write($output);
14119 $xfer += $output->writeFieldEnd();
14120 }
14121 if (defined $self->{systemException}) {
14122 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
14123 $xfer += $self->{systemException}->write($output);
14124 $xfer += $output->writeFieldEnd();
14125 }
14126 $xfer += $output->writeFieldStop();
14127 $xfer += $output->writeStructEnd();
14128 return $xfer;
14129 }
14130  
14131 package Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args;
14132 use base qw(Class::Accessor);
14133 Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->mk_accessors( qw( authenticationToken guid ) );
14134  
14135 sub new {
14136 my $classname = shift;
14137 my $self = {};
14138 my $vals = shift || {};
14139 $self->{authenticationToken} = undef;
14140 $self->{guid} = undef;
14141 if (UNIVERSAL::isa($vals,'HASH')) {
14142 if (defined $vals->{authenticationToken}) {
14143 $self->{authenticationToken} = $vals->{authenticationToken};
14144 }
14145 if (defined $vals->{guid}) {
14146 $self->{guid} = $vals->{guid};
14147 }
14148 }
14149 return bless ($self, $classname);
14150 }
14151  
14152 sub getName {
14153 return 'NoteStore_shareNote_args';
14154 }
14155  
14156 sub read {
14157 my ($self, $input) = @_;
14158 my $xfer = 0;
14159 my $fname;
14160 my $ftype = 0;
14161 my $fid = 0;
14162 $xfer += $input->readStructBegin(\$fname);
14163 while (1)
14164 {
14165 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14166 if ($ftype == TType::STOP) {
14167 last;
14168 }
14169 SWITCH: for($fid)
14170 {
14171 /^1$/ && do{ if ($ftype == TType::STRING) {
14172 $xfer += $input->readString(\$self->{authenticationToken});
14173 } else {
14174 $xfer += $input->skip($ftype);
14175 }
14176 last; };
14177 /^2$/ && do{ if ($ftype == TType::STRING) {
14178 $xfer += $input->readString(\$self->{guid});
14179 } else {
14180 $xfer += $input->skip($ftype);
14181 }
14182 last; };
14183 $xfer += $input->skip($ftype);
14184 }
14185 $xfer += $input->readFieldEnd();
14186 }
14187 $xfer += $input->readStructEnd();
14188 return $xfer;
14189 }
14190  
14191 sub write {
14192 my ($self, $output) = @_;
14193 my $xfer = 0;
14194 $xfer += $output->writeStructBegin('NoteStore_shareNote_args');
14195 if (defined $self->{authenticationToken}) {
14196 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
14197 $xfer += $output->writeString($self->{authenticationToken});
14198 $xfer += $output->writeFieldEnd();
14199 }
14200 if (defined $self->{guid}) {
14201 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
14202 $xfer += $output->writeString($self->{guid});
14203 $xfer += $output->writeFieldEnd();
14204 }
14205 $xfer += $output->writeFieldStop();
14206 $xfer += $output->writeStructEnd();
14207 return $xfer;
14208 }
14209  
14210 package Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result;
14211 use base qw(Class::Accessor);
14212 Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->mk_accessors( qw( success ) );
14213  
14214 sub new {
14215 my $classname = shift;
14216 my $self = {};
14217 my $vals = shift || {};
14218 $self->{success} = undef;
14219 $self->{userException} = undef;
14220 $self->{notFoundException} = undef;
14221 $self->{systemException} = undef;
14222 if (UNIVERSAL::isa($vals,'HASH')) {
14223 if (defined $vals->{success}) {
14224 $self->{success} = $vals->{success};
14225 }
14226 if (defined $vals->{userException}) {
14227 $self->{userException} = $vals->{userException};
14228 }
14229 if (defined $vals->{notFoundException}) {
14230 $self->{notFoundException} = $vals->{notFoundException};
14231 }
14232 if (defined $vals->{systemException}) {
14233 $self->{systemException} = $vals->{systemException};
14234 }
14235 }
14236 return bless ($self, $classname);
14237 }
14238  
14239 sub getName {
14240 return 'NoteStore_shareNote_result';
14241 }
14242  
14243 sub read {
14244 my ($self, $input) = @_;
14245 my $xfer = 0;
14246 my $fname;
14247 my $ftype = 0;
14248 my $fid = 0;
14249 $xfer += $input->readStructBegin(\$fname);
14250 while (1)
14251 {
14252 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14253 if ($ftype == TType::STOP) {
14254 last;
14255 }
14256 SWITCH: for($fid)
14257 {
14258 /^0$/ && do{ if ($ftype == TType::STRING) {
14259 $xfer += $input->readString(\$self->{success});
14260 } else {
14261 $xfer += $input->skip($ftype);
14262 }
14263 last; };
14264 /^1$/ && do{ if ($ftype == TType::STRUCT) {
14265 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
14266 $xfer += $self->{userException}->read($input);
14267 } else {
14268 $xfer += $input->skip($ftype);
14269 }
14270 last; };
14271 /^2$/ && do{ if ($ftype == TType::STRUCT) {
14272 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
14273 $xfer += $self->{notFoundException}->read($input);
14274 } else {
14275 $xfer += $input->skip($ftype);
14276 }
14277 last; };
14278 /^3$/ && do{ if ($ftype == TType::STRUCT) {
14279 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
14280 $xfer += $self->{systemException}->read($input);
14281 } else {
14282 $xfer += $input->skip($ftype);
14283 }
14284 last; };
14285 $xfer += $input->skip($ftype);
14286 }
14287 $xfer += $input->readFieldEnd();
14288 }
14289 $xfer += $input->readStructEnd();
14290 return $xfer;
14291 }
14292  
14293 sub write {
14294 my ($self, $output) = @_;
14295 my $xfer = 0;
14296 $xfer += $output->writeStructBegin('NoteStore_shareNote_result');
14297 if (defined $self->{success}) {
14298 $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
14299 $xfer += $output->writeString($self->{success});
14300 $xfer += $output->writeFieldEnd();
14301 }
14302 if (defined $self->{userException}) {
14303 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
14304 $xfer += $self->{userException}->write($output);
14305 $xfer += $output->writeFieldEnd();
14306 }
14307 if (defined $self->{notFoundException}) {
14308 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
14309 $xfer += $self->{notFoundException}->write($output);
14310 $xfer += $output->writeFieldEnd();
14311 }
14312 if (defined $self->{systemException}) {
14313 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
14314 $xfer += $self->{systemException}->write($output);
14315 $xfer += $output->writeFieldEnd();
14316 }
14317 $xfer += $output->writeFieldStop();
14318 $xfer += $output->writeStructEnd();
14319 return $xfer;
14320 }
14321  
14322 package Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args;
14323 use base qw(Class::Accessor);
14324 Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->mk_accessors( qw( authenticationToken guid ) );
14325  
14326 sub new {
14327 my $classname = shift;
14328 my $self = {};
14329 my $vals = shift || {};
14330 $self->{authenticationToken} = undef;
14331 $self->{guid} = undef;
14332 if (UNIVERSAL::isa($vals,'HASH')) {
14333 if (defined $vals->{authenticationToken}) {
14334 $self->{authenticationToken} = $vals->{authenticationToken};
14335 }
14336 if (defined $vals->{guid}) {
14337 $self->{guid} = $vals->{guid};
14338 }
14339 }
14340 return bless ($self, $classname);
14341 }
14342  
14343 sub getName {
14344 return 'NoteStore_stopSharingNote_args';
14345 }
14346  
14347 sub read {
14348 my ($self, $input) = @_;
14349 my $xfer = 0;
14350 my $fname;
14351 my $ftype = 0;
14352 my $fid = 0;
14353 $xfer += $input->readStructBegin(\$fname);
14354 while (1)
14355 {
14356 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14357 if ($ftype == TType::STOP) {
14358 last;
14359 }
14360 SWITCH: for($fid)
14361 {
14362 /^1$/ && do{ if ($ftype == TType::STRING) {
14363 $xfer += $input->readString(\$self->{authenticationToken});
14364 } else {
14365 $xfer += $input->skip($ftype);
14366 }
14367 last; };
14368 /^2$/ && do{ if ($ftype == TType::STRING) {
14369 $xfer += $input->readString(\$self->{guid});
14370 } else {
14371 $xfer += $input->skip($ftype);
14372 }
14373 last; };
14374 $xfer += $input->skip($ftype);
14375 }
14376 $xfer += $input->readFieldEnd();
14377 }
14378 $xfer += $input->readStructEnd();
14379 return $xfer;
14380 }
14381  
14382 sub write {
14383 my ($self, $output) = @_;
14384 my $xfer = 0;
14385 $xfer += $output->writeStructBegin('NoteStore_stopSharingNote_args');
14386 if (defined $self->{authenticationToken}) {
14387 $xfer += $output->writeFieldBegin('authenticationToken', TType::STRING, 1);
14388 $xfer += $output->writeString($self->{authenticationToken});
14389 $xfer += $output->writeFieldEnd();
14390 }
14391 if (defined $self->{guid}) {
14392 $xfer += $output->writeFieldBegin('guid', TType::STRING, 2);
14393 $xfer += $output->writeString($self->{guid});
14394 $xfer += $output->writeFieldEnd();
14395 }
14396 $xfer += $output->writeFieldStop();
14397 $xfer += $output->writeStructEnd();
14398 return $xfer;
14399 }
14400  
14401 package Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result;
14402 use base qw(Class::Accessor);
14403 Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->mk_accessors( qw( ) );
14404  
14405 sub new {
14406 my $classname = shift;
14407 my $self = {};
14408 my $vals = shift || {};
14409 $self->{userException} = undef;
14410 $self->{notFoundException} = undef;
14411 $self->{systemException} = undef;
14412 if (UNIVERSAL::isa($vals,'HASH')) {
14413 if (defined $vals->{userException}) {
14414 $self->{userException} = $vals->{userException};
14415 }
14416 if (defined $vals->{notFoundException}) {
14417 $self->{notFoundException} = $vals->{notFoundException};
14418 }
14419 if (defined $vals->{systemException}) {
14420 $self->{systemException} = $vals->{systemException};
14421 }
14422 }
14423 return bless ($self, $classname);
14424 }
14425  
14426 sub getName {
14427 return 'NoteStore_stopSharingNote_result';
14428 }
14429  
14430 sub read {
14431 my ($self, $input) = @_;
14432 my $xfer = 0;
14433 my $fname;
14434 my $ftype = 0;
14435 my $fid = 0;
14436 $xfer += $input->readStructBegin(\$fname);
14437 while (1)
14438 {
14439 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14440 if ($ftype == TType::STOP) {
14441 last;
14442 }
14443 SWITCH: for($fid)
14444 {
14445 /^1$/ && do{ if ($ftype == TType::STRUCT) {
14446 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
14447 $xfer += $self->{userException}->read($input);
14448 } else {
14449 $xfer += $input->skip($ftype);
14450 }
14451 last; };
14452 /^2$/ && do{ if ($ftype == TType::STRUCT) {
14453 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
14454 $xfer += $self->{notFoundException}->read($input);
14455 } else {
14456 $xfer += $input->skip($ftype);
14457 }
14458 last; };
14459 /^3$/ && do{ if ($ftype == TType::STRUCT) {
14460 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
14461 $xfer += $self->{systemException}->read($input);
14462 } else {
14463 $xfer += $input->skip($ftype);
14464 }
14465 last; };
14466 $xfer += $input->skip($ftype);
14467 }
14468 $xfer += $input->readFieldEnd();
14469 }
14470 $xfer += $input->readStructEnd();
14471 return $xfer;
14472 }
14473  
14474 sub write {
14475 my ($self, $output) = @_;
14476 my $xfer = 0;
14477 $xfer += $output->writeStructBegin('NoteStore_stopSharingNote_result');
14478 if (defined $self->{userException}) {
14479 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
14480 $xfer += $self->{userException}->write($output);
14481 $xfer += $output->writeFieldEnd();
14482 }
14483 if (defined $self->{notFoundException}) {
14484 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
14485 $xfer += $self->{notFoundException}->write($output);
14486 $xfer += $output->writeFieldEnd();
14487 }
14488 if (defined $self->{systemException}) {
14489 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
14490 $xfer += $self->{systemException}->write($output);
14491 $xfer += $output->writeFieldEnd();
14492 }
14493 $xfer += $output->writeFieldStop();
14494 $xfer += $output->writeStructEnd();
14495 return $xfer;
14496 }
14497  
14498 package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args;
14499 use base qw(Class::Accessor);
14500 Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->mk_accessors( qw( guid noteKey ) );
14501  
14502 sub new {
14503 my $classname = shift;
14504 my $self = {};
14505 my $vals = shift || {};
14506 $self->{guid} = undef;
14507 $self->{noteKey} = undef;
14508 if (UNIVERSAL::isa($vals,'HASH')) {
14509 if (defined $vals->{guid}) {
14510 $self->{guid} = $vals->{guid};
14511 }
14512 if (defined $vals->{noteKey}) {
14513 $self->{noteKey} = $vals->{noteKey};
14514 }
14515 }
14516 return bless ($self, $classname);
14517 }
14518  
14519 sub getName {
14520 return 'NoteStore_authenticateToSharedNote_args';
14521 }
14522  
14523 sub read {
14524 my ($self, $input) = @_;
14525 my $xfer = 0;
14526 my $fname;
14527 my $ftype = 0;
14528 my $fid = 0;
14529 $xfer += $input->readStructBegin(\$fname);
14530 while (1)
14531 {
14532 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14533 if ($ftype == TType::STOP) {
14534 last;
14535 }
14536 SWITCH: for($fid)
14537 {
14538 /^1$/ && do{ if ($ftype == TType::STRING) {
14539 $xfer += $input->readString(\$self->{guid});
14540 } else {
14541 $xfer += $input->skip($ftype);
14542 }
14543 last; };
14544 /^2$/ && do{ if ($ftype == TType::STRING) {
14545 $xfer += $input->readString(\$self->{noteKey});
14546 } else {
14547 $xfer += $input->skip($ftype);
14548 }
14549 last; };
14550 $xfer += $input->skip($ftype);
14551 }
14552 $xfer += $input->readFieldEnd();
14553 }
14554 $xfer += $input->readStructEnd();
14555 return $xfer;
14556 }
14557  
14558 sub write {
14559 my ($self, $output) = @_;
14560 my $xfer = 0;
14561 $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNote_args');
14562 if (defined $self->{guid}) {
14563 $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
14564 $xfer += $output->writeString($self->{guid});
14565 $xfer += $output->writeFieldEnd();
14566 }
14567 if (defined $self->{noteKey}) {
14568 $xfer += $output->writeFieldBegin('noteKey', TType::STRING, 2);
14569 $xfer += $output->writeString($self->{noteKey});
14570 $xfer += $output->writeFieldEnd();
14571 }
14572 $xfer += $output->writeFieldStop();
14573 $xfer += $output->writeStructEnd();
14574 return $xfer;
14575 }
14576  
14577 package Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result;
14578 use base qw(Class::Accessor);
14579 Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->mk_accessors( qw( success ) );
14580  
14581 sub new {
14582 my $classname = shift;
14583 my $self = {};
14584 my $vals = shift || {};
14585 $self->{success} = undef;
14586 $self->{userException} = undef;
14587 $self->{notFoundException} = undef;
14588 $self->{systemException} = undef;
14589 if (UNIVERSAL::isa($vals,'HASH')) {
14590 if (defined $vals->{success}) {
14591 $self->{success} = $vals->{success};
14592 }
14593 if (defined $vals->{userException}) {
14594 $self->{userException} = $vals->{userException};
14595 }
14596 if (defined $vals->{notFoundException}) {
14597 $self->{notFoundException} = $vals->{notFoundException};
14598 }
14599 if (defined $vals->{systemException}) {
14600 $self->{systemException} = $vals->{systemException};
14601 }
14602 }
14603 return bless ($self, $classname);
14604 }
14605  
14606 sub getName {
14607 return 'NoteStore_authenticateToSharedNote_result';
14608 }
14609  
14610 sub read {
14611 my ($self, $input) = @_;
14612 my $xfer = 0;
14613 my $fname;
14614 my $ftype = 0;
14615 my $fid = 0;
14616 $xfer += $input->readStructBegin(\$fname);
14617 while (1)
14618 {
14619 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
14620 if ($ftype == TType::STOP) {
14621 last;
14622 }
14623 SWITCH: for($fid)
14624 {
14625 /^0$/ && do{ if ($ftype == TType::STRUCT) {
14626 $self->{success} = Net::Evernote::EDAMUserStore::AuthenticationResult->new();
14627 $xfer += $self->{success}->read($input);
14628 } else {
14629 $xfer += $input->skip($ftype);
14630 }
14631 last; };
14632 /^1$/ && do{ if ($ftype == TType::STRUCT) {
14633 $self->{userException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException->new();
14634 $xfer += $self->{userException}->read($input);
14635 } else {
14636 $xfer += $input->skip($ftype);
14637 }
14638 last; };
14639 /^2$/ && do{ if ($ftype == TType::STRUCT) {
14640 $self->{notFoundException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException->new();
14641 $xfer += $self->{notFoundException}->read($input);
14642 } else {
14643 $xfer += $input->skip($ftype);
14644 }
14645 last; };
14646 /^3$/ && do{ if ($ftype == TType::STRUCT) {
14647 $self->{systemException} = Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException->new();
14648 $xfer += $self->{systemException}->read($input);
14649 } else {
14650 $xfer += $input->skip($ftype);
14651 }
14652 last; };
14653 $xfer += $input->skip($ftype);
14654 }
14655 $xfer += $input->readFieldEnd();
14656 }
14657 $xfer += $input->readStructEnd();
14658 return $xfer;
14659 }
14660  
14661 sub write {
14662 my ($self, $output) = @_;
14663 my $xfer = 0;
14664 $xfer += $output->writeStructBegin('NoteStore_authenticateToSharedNote_result');
14665 if (defined $self->{success}) {
14666 $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
14667 $xfer += $self->{success}->write($output);
14668 $xfer += $output->writeFieldEnd();
14669 }
14670 if (defined $self->{userException}) {
14671 $xfer += $output->writeFieldBegin('userException', TType::STRUCT, 1);
14672 $xfer += $self->{userException}->write($output);
14673 $xfer += $output->writeFieldEnd();
14674 }
14675 if (defined $self->{notFoundException}) {
14676 $xfer += $output->writeFieldBegin('notFoundException', TType::STRUCT, 2);
14677 $xfer += $self->{notFoundException}->write($output);
14678 $xfer += $output->writeFieldEnd();
14679 }
14680 if (defined $self->{systemException}) {
14681 $xfer += $output->writeFieldBegin('systemException', TType::STRUCT, 3);
14682 $xfer += $self->{systemException}->write($output);
14683 $xfer += $output->writeFieldEnd();
14684 }
14685 $xfer += $output->writeFieldStop();
14686 $xfer += $output->writeStructEnd();
14687 return $xfer;
14688 }
14689  
14690 package Net::Evernote::EDAMNoteStore::NoteStoreIf;
14691  
14692 use strict;
14693  
14694  
14695 sub getSyncState{
14696 my $self = shift;
14697 my $authenticationToken = shift;
14698  
14699 die 'implement interface';
14700 }
14701  
14702 sub getSyncChunk{
14703 my $self = shift;
14704 my $authenticationToken = shift;
14705 my $afterUSN = shift;
14706 my $maxEntries = shift;
14707 my $fullSyncOnly = shift;
14708  
14709 die 'implement interface';
14710 }
14711  
14712 sub getFilteredSyncChunk{
14713 my $self = shift;
14714 my $authenticationToken = shift;
14715 my $afterUSN = shift;
14716 my $maxEntries = shift;
14717 my $filter = shift;
14718  
14719 die 'implement interface';
14720 }
14721  
14722 sub getLinkedNotebookSyncState{
14723 my $self = shift;
14724 my $authenticationToken = shift;
14725 my $linkedNotebook = shift;
14726  
14727 die 'implement interface';
14728 }
14729  
14730 sub getLinkedNotebookSyncChunk{
14731 my $self = shift;
14732 my $authenticationToken = shift;
14733 my $linkedNotebook = shift;
14734 my $afterUSN = shift;
14735 my $maxEntries = shift;
14736 my $fullSyncOnly = shift;
14737  
14738 die 'implement interface';
14739 }
14740  
14741 sub listNotebooks{
14742 my $self = shift;
14743 my $authenticationToken = shift;
14744  
14745 die 'implement interface';
14746 }
14747  
14748 sub getNotebook{
14749 my $self = shift;
14750 my $authenticationToken = shift;
14751 my $guid = shift;
14752  
14753 die 'implement interface';
14754 }
14755  
14756 sub getDefaultNotebook{
14757 my $self = shift;
14758 my $authenticationToken = shift;
14759  
14760 die 'implement interface';
14761 }
14762  
14763 sub createNotebook{
14764 my $self = shift;
14765 my $authenticationToken = shift;
14766 my $notebook = shift;
14767  
14768 die 'implement interface';
14769 }
14770  
14771 sub updateNotebook{
14772 my $self = shift;
14773 my $authenticationToken = shift;
14774 my $notebook = shift;
14775  
14776 die 'implement interface';
14777 }
14778  
14779 sub expungeNotebook{
14780 my $self = shift;
14781 my $authenticationToken = shift;
14782 my $guid = shift;
14783  
14784 die 'implement interface';
14785 }
14786  
14787 sub listTags{
14788 my $self = shift;
14789 my $authenticationToken = shift;
14790  
14791 die 'implement interface';
14792 }
14793  
14794 sub listTagsByNotebook{
14795 my $self = shift;
14796 my $authenticationToken = shift;
14797 my $notebookGuid = shift;
14798  
14799 die 'implement interface';
14800 }
14801  
14802 sub getTag{
14803 my $self = shift;
14804 my $authenticationToken = shift;
14805 my $guid = shift;
14806  
14807 die 'implement interface';
14808 }
14809  
14810 sub createTag{
14811 my $self = shift;
14812 my $authenticationToken = shift;
14813 my $tag = shift;
14814  
14815 die 'implement interface';
14816 }
14817  
14818 sub updateTag{
14819 my $self = shift;
14820 my $authenticationToken = shift;
14821 my $tag = shift;
14822  
14823 die 'implement interface';
14824 }
14825  
14826 sub untagAll{
14827 my $self = shift;
14828 my $authenticationToken = shift;
14829 my $guid = shift;
14830  
14831 die 'implement interface';
14832 }
14833  
14834 sub expungeTag{
14835 my $self = shift;
14836 my $authenticationToken = shift;
14837 my $guid = shift;
14838  
14839 die 'implement interface';
14840 }
14841  
14842 sub listSearches{
14843 my $self = shift;
14844 my $authenticationToken = shift;
14845  
14846 die 'implement interface';
14847 }
14848  
14849 sub getSearch{
14850 my $self = shift;
14851 my $authenticationToken = shift;
14852 my $guid = shift;
14853  
14854 die 'implement interface';
14855 }
14856  
14857 sub createSearch{
14858 my $self = shift;
14859 my $authenticationToken = shift;
14860 my $search = shift;
14861  
14862 die 'implement interface';
14863 }
14864  
14865 sub updateSearch{
14866 my $self = shift;
14867 my $authenticationToken = shift;
14868 my $search = shift;
14869  
14870 die 'implement interface';
14871 }
14872  
14873 sub expungeSearch{
14874 my $self = shift;
14875 my $authenticationToken = shift;
14876 my $guid = shift;
14877  
14878 die 'implement interface';
14879 }
14880  
14881 sub findNotes{
14882 my $self = shift;
14883 my $authenticationToken = shift;
14884 my $filter = shift;
14885 my $offset = shift;
14886 my $maxNotes = shift;
14887  
14888 die 'implement interface';
14889 }
14890  
14891 sub findNoteOffset{
14892 my $self = shift;
14893 my $authenticationToken = shift;
14894 my $filter = shift;
14895 my $guid = shift;
14896  
14897 die 'implement interface';
14898 }
14899  
14900 sub findNotesMetadata{
14901 my $self = shift;
14902 my $authenticationToken = shift;
14903 my $filter = shift;
14904 my $offset = shift;
14905 my $maxNotes = shift;
14906 my $resultSpec = shift;
14907  
14908 die 'implement interface';
14909 }
14910  
14911 sub findNoteCounts{
14912 my $self = shift;
14913 my $authenticationToken = shift;
14914 my $filter = shift;
14915 my $withTrash = shift;
14916  
14917 die 'implement interface';
14918 }
14919  
14920 sub getNote{
14921 my $self = shift;
14922 my $authenticationToken = shift;
14923 my $guid = shift;
14924 my $withContent = shift;
14925 my $withResourcesData = shift;
14926 my $withResourcesRecognition = shift;
14927 my $withResourcesAlternateData = shift;
14928  
14929 die 'implement interface';
14930 }
14931  
14932 sub getNoteApplicationData{
14933 my $self = shift;
14934 my $authenticationToken = shift;
14935 my $guid = shift;
14936  
14937 die 'implement interface';
14938 }
14939  
14940 sub getNoteApplicationDataEntry{
14941 my $self = shift;
14942 my $authenticationToken = shift;
14943 my $guid = shift;
14944 my $key = shift;
14945  
14946 die 'implement interface';
14947 }
14948  
14949 sub setNoteApplicationDataEntry{
14950 my $self = shift;
14951 my $authenticationToken = shift;
14952 my $guid = shift;
14953 my $key = shift;
14954 my $value = shift;
14955  
14956 die 'implement interface';
14957 }
14958  
14959 sub unsetNoteApplicationDataEntry{
14960 my $self = shift;
14961 my $authenticationToken = shift;
14962 my $guid = shift;
14963 my $key = shift;
14964  
14965 die 'implement interface';
14966 }
14967  
14968 sub getNoteContent{
14969 my $self = shift;
14970 my $authenticationToken = shift;
14971 my $guid = shift;
14972  
14973 die 'implement interface';
14974 }
14975  
14976 sub getNoteSearchText{
14977 my $self = shift;
14978 my $authenticationToken = shift;
14979 my $guid = shift;
14980 my $noteOnly = shift;
14981 my $tokenizeForIndexing = shift;
14982  
14983 die 'implement interface';
14984 }
14985  
14986 sub getResourceSearchText{
14987 my $self = shift;
14988 my $authenticationToken = shift;
14989 my $guid = shift;
14990  
14991 die 'implement interface';
14992 }
14993  
14994 sub getNoteTagNames{
14995 my $self = shift;
14996 my $authenticationToken = shift;
14997 my $guid = shift;
14998  
14999 die 'implement interface';
15000 }
15001  
15002 sub createNote{
15003 my $self = shift;
15004 my $authenticationToken = shift;
15005 my $note = shift;
15006  
15007 die 'implement interface';
15008 }
15009  
15010 sub updateNote{
15011 my $self = shift;
15012 my $authenticationToken = shift;
15013 my $note = shift;
15014  
15015 die 'implement interface';
15016 }
15017  
15018 sub deleteNote{
15019 my $self = shift;
15020 my $authenticationToken = shift;
15021 my $guid = shift;
15022  
15023 die 'implement interface';
15024 }
15025  
15026 sub expungeNote{
15027 my $self = shift;
15028 my $authenticationToken = shift;
15029 my $guid = shift;
15030  
15031 die 'implement interface';
15032 }
15033  
15034 sub expungeNotes{
15035 my $self = shift;
15036 my $authenticationToken = shift;
15037 my $noteGuids = shift;
15038  
15039 die 'implement interface';
15040 }
15041  
15042 sub expungeInactiveNotes{
15043 my $self = shift;
15044 my $authenticationToken = shift;
15045  
15046 die 'implement interface';
15047 }
15048  
15049 sub copyNote{
15050 my $self = shift;
15051 my $authenticationToken = shift;
15052 my $noteGuid = shift;
15053 my $toNotebookGuid = shift;
15054  
15055 die 'implement interface';
15056 }
15057  
15058 sub listNoteVersions{
15059 my $self = shift;
15060 my $authenticationToken = shift;
15061 my $noteGuid = shift;
15062  
15063 die 'implement interface';
15064 }
15065  
15066 sub getNoteVersion{
15067 my $self = shift;
15068 my $authenticationToken = shift;
15069 my $noteGuid = shift;
15070 my $updateSequenceNum = shift;
15071 my $withResourcesData = shift;
15072 my $withResourcesRecognition = shift;
15073 my $withResourcesAlternateData = shift;
15074  
15075 die 'implement interface';
15076 }
15077  
15078 sub getResource{
15079 my $self = shift;
15080 my $authenticationToken = shift;
15081 my $guid = shift;
15082 my $withData = shift;
15083 my $withRecognition = shift;
15084 my $withAttributes = shift;
15085 my $withAlternateData = shift;
15086  
15087 die 'implement interface';
15088 }
15089  
15090 sub getResourceApplicationData{
15091 my $self = shift;
15092 my $authenticationToken = shift;
15093 my $guid = shift;
15094  
15095 die 'implement interface';
15096 }
15097  
15098 sub getResourceApplicationDataEntry{
15099 my $self = shift;
15100 my $authenticationToken = shift;
15101 my $guid = shift;
15102 my $key = shift;
15103  
15104 die 'implement interface';
15105 }
15106  
15107 sub setResourceApplicationDataEntry{
15108 my $self = shift;
15109 my $authenticationToken = shift;
15110 my $guid = shift;
15111 my $key = shift;
15112 my $value = shift;
15113  
15114 die 'implement interface';
15115 }
15116  
15117 sub unsetResourceApplicationDataEntry{
15118 my $self = shift;
15119 my $authenticationToken = shift;
15120 my $guid = shift;
15121 my $key = shift;
15122  
15123 die 'implement interface';
15124 }
15125  
15126 sub updateResource{
15127 my $self = shift;
15128 my $authenticationToken = shift;
15129 my $resource = shift;
15130  
15131 die 'implement interface';
15132 }
15133  
15134 sub getResourceData{
15135 my $self = shift;
15136 my $authenticationToken = shift;
15137 my $guid = shift;
15138  
15139 die 'implement interface';
15140 }
15141  
15142 sub getResourceByHash{
15143 my $self = shift;
15144 my $authenticationToken = shift;
15145 my $noteGuid = shift;
15146 my $contentHash = shift;
15147 my $withData = shift;
15148 my $withRecognition = shift;
15149 my $withAlternateData = shift;
15150  
15151 die 'implement interface';
15152 }
15153  
15154 sub getResourceRecognition{
15155 my $self = shift;
15156 my $authenticationToken = shift;
15157 my $guid = shift;
15158  
15159 die 'implement interface';
15160 }
15161  
15162 sub getResourceAlternateData{
15163 my $self = shift;
15164 my $authenticationToken = shift;
15165 my $guid = shift;
15166  
15167 die 'implement interface';
15168 }
15169  
15170 sub getResourceAttributes{
15171 my $self = shift;
15172 my $authenticationToken = shift;
15173 my $guid = shift;
15174  
15175 die 'implement interface';
15176 }
15177  
15178 sub getAccountSize{
15179 my $self = shift;
15180 my $authenticationToken = shift;
15181  
15182 die 'implement interface';
15183 }
15184  
15185 sub getAds{
15186 my $self = shift;
15187 my $authenticationToken = shift;
15188 my $adParameters = shift;
15189  
15190 die 'implement interface';
15191 }
15192  
15193 sub getRandomAd{
15194 my $self = shift;
15195 my $authenticationToken = shift;
15196 my $adParameters = shift;
15197  
15198 die 'implement interface';
15199 }
15200  
15201 sub getPublicNotebook{
15202 my $self = shift;
15203 my $userId = shift;
15204 my $publicUri = shift;
15205  
15206 die 'implement interface';
15207 }
15208  
15209 sub createSharedNotebook{
15210 my $self = shift;
15211 my $authenticationToken = shift;
15212 my $sharedNotebook = shift;
15213  
15214 die 'implement interface';
15215 }
15216  
15217 sub sendMessageToSharedNotebookMembers{
15218 my $self = shift;
15219 my $authenticationToken = shift;
15220 my $notebookGuid = shift;
15221 my $messageText = shift;
15222 my $recipients = shift;
15223  
15224 die 'implement interface';
15225 }
15226  
15227 sub listSharedNotebooks{
15228 my $self = shift;
15229 my $authenticationToken = shift;
15230  
15231 die 'implement interface';
15232 }
15233  
15234 sub expungeSharedNotebooks{
15235 my $self = shift;
15236 my $authenticationToken = shift;
15237 my $sharedNotebookIds = shift;
15238  
15239 die 'implement interface';
15240 }
15241  
15242 sub createLinkedNotebook{
15243 my $self = shift;
15244 my $authenticationToken = shift;
15245 my $linkedNotebook = shift;
15246  
15247 die 'implement interface';
15248 }
15249  
15250 sub updateLinkedNotebook{
15251 my $self = shift;
15252 my $authenticationToken = shift;
15253 my $linkedNotebook = shift;
15254  
15255 die 'implement interface';
15256 }
15257  
15258 sub listLinkedNotebooks{
15259 my $self = shift;
15260 my $authenticationToken = shift;
15261  
15262 die 'implement interface';
15263 }
15264  
15265 sub expungeLinkedNotebook{
15266 my $self = shift;
15267 my $authenticationToken = shift;
15268 my $guid = shift;
15269  
15270 die 'implement interface';
15271 }
15272  
15273 sub authenticateToSharedNotebook{
15274 my $self = shift;
15275 my $shareKey = shift;
15276 my $authenticationToken = shift;
15277  
15278 die 'implement interface';
15279 }
15280  
15281 sub getSharedNotebookByAuth{
15282 my $self = shift;
15283 my $authenticationToken = shift;
15284  
15285 die 'implement interface';
15286 }
15287  
15288 sub emailNote{
15289 my $self = shift;
15290 my $authenticationToken = shift;
15291 my $parameters = shift;
15292  
15293 die 'implement interface';
15294 }
15295  
15296 sub shareNote{
15297 my $self = shift;
15298 my $authenticationToken = shift;
15299 my $guid = shift;
15300  
15301 die 'implement interface';
15302 }
15303  
15304 sub stopSharingNote{
15305 my $self = shift;
15306 my $authenticationToken = shift;
15307 my $guid = shift;
15308  
15309 die 'implement interface';
15310 }
15311  
15312 sub authenticateToSharedNote{
15313 my $self = shift;
15314 my $guid = shift;
15315 my $noteKey = shift;
15316  
15317 die 'implement interface';
15318 }
15319  
15320 package Net::Evernote::EDAMNoteStore::NoteStoreRest;
15321  
15322 use strict;
15323  
15324  
15325 sub new {
15326 my ($classname, $impl) = @_;
15327 my $self ={ impl => $impl };
15328  
15329 return bless($self,$classname);
15330 }
15331  
15332 sub getSyncState{
15333 my ($self, $request) = @_;
15334  
15335 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15336 return $self->{impl}->getSyncState($authenticationToken);
15337 }
15338  
15339 sub getSyncChunk{
15340 my ($self, $request) = @_;
15341  
15342 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15343 my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
15344 my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
15345 my $fullSyncOnly = ($request->{'fullSyncOnly'}) ? $request->{'fullSyncOnly'} : undef;
15346 return $self->{impl}->getSyncChunk($authenticationToken, $afterUSN, $maxEntries, $fullSyncOnly);
15347 }
15348  
15349 sub getFilteredSyncChunk{
15350 my ($self, $request) = @_;
15351  
15352 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15353 my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
15354 my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
15355 my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
15356 return $self->{impl}->getFilteredSyncChunk($authenticationToken, $afterUSN, $maxEntries, $filter);
15357 }
15358  
15359 sub getLinkedNotebookSyncState{
15360 my ($self, $request) = @_;
15361  
15362 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15363 my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
15364 return $self->{impl}->getLinkedNotebookSyncState($authenticationToken, $linkedNotebook);
15365 }
15366  
15367 sub getLinkedNotebookSyncChunk{
15368 my ($self, $request) = @_;
15369  
15370 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15371 my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
15372 my $afterUSN = ($request->{'afterUSN'}) ? $request->{'afterUSN'} : undef;
15373 my $maxEntries = ($request->{'maxEntries'}) ? $request->{'maxEntries'} : undef;
15374 my $fullSyncOnly = ($request->{'fullSyncOnly'}) ? $request->{'fullSyncOnly'} : undef;
15375 return $self->{impl}->getLinkedNotebookSyncChunk($authenticationToken, $linkedNotebook, $afterUSN, $maxEntries, $fullSyncOnly);
15376 }
15377  
15378 sub listNotebooks{
15379 my ($self, $request) = @_;
15380  
15381 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15382 return $self->{impl}->listNotebooks($authenticationToken);
15383 }
15384  
15385 sub getNotebook{
15386 my ($self, $request) = @_;
15387  
15388 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15389 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15390 return $self->{impl}->getNotebook($authenticationToken, $guid);
15391 }
15392  
15393 sub getDefaultNotebook{
15394 my ($self, $request) = @_;
15395  
15396 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15397 return $self->{impl}->getDefaultNotebook($authenticationToken);
15398 }
15399  
15400 sub createNotebook{
15401 my ($self, $request) = @_;
15402  
15403 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15404 my $notebook = ($request->{'notebook'}) ? $request->{'notebook'} : undef;
15405 return $self->{impl}->createNotebook($authenticationToken, $notebook);
15406 }
15407  
15408 sub updateNotebook{
15409 my ($self, $request) = @_;
15410  
15411 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15412 my $notebook = ($request->{'notebook'}) ? $request->{'notebook'} : undef;
15413 return $self->{impl}->updateNotebook($authenticationToken, $notebook);
15414 }
15415  
15416 sub expungeNotebook{
15417 my ($self, $request) = @_;
15418  
15419 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15420 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15421 return $self->{impl}->expungeNotebook($authenticationToken, $guid);
15422 }
15423  
15424 sub listTags{
15425 my ($self, $request) = @_;
15426  
15427 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15428 return $self->{impl}->listTags($authenticationToken);
15429 }
15430  
15431 sub listTagsByNotebook{
15432 my ($self, $request) = @_;
15433  
15434 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15435 my $notebookGuid = ($request->{'notebookGuid'}) ? $request->{'notebookGuid'} : undef;
15436 return $self->{impl}->listTagsByNotebook($authenticationToken, $notebookGuid);
15437 }
15438  
15439 sub getTag{
15440 my ($self, $request) = @_;
15441  
15442 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15443 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15444 return $self->{impl}->getTag($authenticationToken, $guid);
15445 }
15446  
15447 sub createTag{
15448 my ($self, $request) = @_;
15449  
15450 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15451 my $tag = ($request->{'tag'}) ? $request->{'tag'} : undef;
15452 return $self->{impl}->createTag($authenticationToken, $tag);
15453 }
15454  
15455 sub updateTag{
15456 my ($self, $request) = @_;
15457  
15458 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15459 my $tag = ($request->{'tag'}) ? $request->{'tag'} : undef;
15460 return $self->{impl}->updateTag($authenticationToken, $tag);
15461 }
15462  
15463 sub untagAll{
15464 my ($self, $request) = @_;
15465  
15466 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15467 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15468 return $self->{impl}->untagAll($authenticationToken, $guid);
15469 }
15470  
15471 sub expungeTag{
15472 my ($self, $request) = @_;
15473  
15474 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15475 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15476 return $self->{impl}->expungeTag($authenticationToken, $guid);
15477 }
15478  
15479 sub listSearches{
15480 my ($self, $request) = @_;
15481  
15482 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15483 return $self->{impl}->listSearches($authenticationToken);
15484 }
15485  
15486 sub getSearch{
15487 my ($self, $request) = @_;
15488  
15489 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15490 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15491 return $self->{impl}->getSearch($authenticationToken, $guid);
15492 }
15493  
15494 sub createSearch{
15495 my ($self, $request) = @_;
15496  
15497 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15498 my $search = ($request->{'search'}) ? $request->{'search'} : undef;
15499 return $self->{impl}->createSearch($authenticationToken, $search);
15500 }
15501  
15502 sub updateSearch{
15503 my ($self, $request) = @_;
15504  
15505 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15506 my $search = ($request->{'search'}) ? $request->{'search'} : undef;
15507 return $self->{impl}->updateSearch($authenticationToken, $search);
15508 }
15509  
15510 sub expungeSearch{
15511 my ($self, $request) = @_;
15512  
15513 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15514 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15515 return $self->{impl}->expungeSearch($authenticationToken, $guid);
15516 }
15517  
15518 sub findNotes{
15519 my ($self, $request) = @_;
15520  
15521 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15522 my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
15523 my $offset = ($request->{'offset'}) ? $request->{'offset'} : undef;
15524 my $maxNotes = ($request->{'maxNotes'}) ? $request->{'maxNotes'} : undef;
15525 return $self->{impl}->findNotes($authenticationToken, $filter, $offset, $maxNotes);
15526 }
15527  
15528 sub findNoteOffset{
15529 my ($self, $request) = @_;
15530  
15531 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15532 my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
15533 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15534 return $self->{impl}->findNoteOffset($authenticationToken, $filter, $guid);
15535 }
15536  
15537 sub findNotesMetadata{
15538 my ($self, $request) = @_;
15539  
15540 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15541 my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
15542 my $offset = ($request->{'offset'}) ? $request->{'offset'} : undef;
15543 my $maxNotes = ($request->{'maxNotes'}) ? $request->{'maxNotes'} : undef;
15544 my $resultSpec = ($request->{'resultSpec'}) ? $request->{'resultSpec'} : undef;
15545 return $self->{impl}->findNotesMetadata($authenticationToken, $filter, $offset, $maxNotes, $resultSpec);
15546 }
15547  
15548 sub findNoteCounts{
15549 my ($self, $request) = @_;
15550  
15551 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15552 my $filter = ($request->{'filter'}) ? $request->{'filter'} : undef;
15553 my $withTrash = ($request->{'withTrash'}) ? $request->{'withTrash'} : undef;
15554 return $self->{impl}->findNoteCounts($authenticationToken, $filter, $withTrash);
15555 }
15556  
15557 sub getNote{
15558 my ($self, $request) = @_;
15559  
15560 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15561 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15562 my $withContent = ($request->{'withContent'}) ? $request->{'withContent'} : undef;
15563 my $withResourcesData = ($request->{'withResourcesData'}) ? $request->{'withResourcesData'} : undef;
15564 my $withResourcesRecognition = ($request->{'withResourcesRecognition'}) ? $request->{'withResourcesRecognition'} : undef;
15565 my $withResourcesAlternateData = ($request->{'withResourcesAlternateData'}) ? $request->{'withResourcesAlternateData'} : undef;
15566 return $self->{impl}->getNote($authenticationToken, $guid, $withContent, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
15567 }
15568  
15569 sub getNoteApplicationData{
15570 my ($self, $request) = @_;
15571  
15572 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15573 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15574 return $self->{impl}->getNoteApplicationData($authenticationToken, $guid);
15575 }
15576  
15577 sub getNoteApplicationDataEntry{
15578 my ($self, $request) = @_;
15579  
15580 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15581 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15582 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15583 return $self->{impl}->getNoteApplicationDataEntry($authenticationToken, $guid, $key);
15584 }
15585  
15586 sub setNoteApplicationDataEntry{
15587 my ($self, $request) = @_;
15588  
15589 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15590 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15591 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15592 my $value = ($request->{'value'}) ? $request->{'value'} : undef;
15593 return $self->{impl}->setNoteApplicationDataEntry($authenticationToken, $guid, $key, $value);
15594 }
15595  
15596 sub unsetNoteApplicationDataEntry{
15597 my ($self, $request) = @_;
15598  
15599 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15600 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15601 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15602 return $self->{impl}->unsetNoteApplicationDataEntry($authenticationToken, $guid, $key);
15603 }
15604  
15605 sub getNoteContent{
15606 my ($self, $request) = @_;
15607  
15608 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15609 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15610 return $self->{impl}->getNoteContent($authenticationToken, $guid);
15611 }
15612  
15613 sub getNoteSearchText{
15614 my ($self, $request) = @_;
15615  
15616 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15617 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15618 my $noteOnly = ($request->{'noteOnly'}) ? $request->{'noteOnly'} : undef;
15619 my $tokenizeForIndexing = ($request->{'tokenizeForIndexing'}) ? $request->{'tokenizeForIndexing'} : undef;
15620 return $self->{impl}->getNoteSearchText($authenticationToken, $guid, $noteOnly, $tokenizeForIndexing);
15621 }
15622  
15623 sub getResourceSearchText{
15624 my ($self, $request) = @_;
15625  
15626 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15627 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15628 return $self->{impl}->getResourceSearchText($authenticationToken, $guid);
15629 }
15630  
15631 sub getNoteTagNames{
15632 my ($self, $request) = @_;
15633  
15634 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15635 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15636 return $self->{impl}->getNoteTagNames($authenticationToken, $guid);
15637 }
15638  
15639 sub createNote{
15640 my ($self, $request) = @_;
15641  
15642 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15643 my $note = ($request->{'note'}) ? $request->{'note'} : undef;
15644 return $self->{impl}->createNote($authenticationToken, $note);
15645 }
15646  
15647 sub updateNote{
15648 my ($self, $request) = @_;
15649  
15650 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15651 my $note = ($request->{'note'}) ? $request->{'note'} : undef;
15652 return $self->{impl}->updateNote($authenticationToken, $note);
15653 }
15654  
15655 sub deleteNote{
15656 my ($self, $request) = @_;
15657  
15658 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15659 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15660 return $self->{impl}->deleteNote($authenticationToken, $guid);
15661 }
15662  
15663 sub expungeNote{
15664 my ($self, $request) = @_;
15665  
15666 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15667 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15668 return $self->{impl}->expungeNote($authenticationToken, $guid);
15669 }
15670  
15671 sub expungeNotes{
15672 my ($self, $request) = @_;
15673  
15674 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15675 my $noteGuids = ($request->{'noteGuids'}) ? $request->{'noteGuids'} : undef;
15676 return $self->{impl}->expungeNotes($authenticationToken, $noteGuids);
15677 }
15678  
15679 sub expungeInactiveNotes{
15680 my ($self, $request) = @_;
15681  
15682 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15683 return $self->{impl}->expungeInactiveNotes($authenticationToken);
15684 }
15685  
15686 sub copyNote{
15687 my ($self, $request) = @_;
15688  
15689 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15690 my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
15691 my $toNotebookGuid = ($request->{'toNotebookGuid'}) ? $request->{'toNotebookGuid'} : undef;
15692 return $self->{impl}->copyNote($authenticationToken, $noteGuid, $toNotebookGuid);
15693 }
15694  
15695 sub listNoteVersions{
15696 my ($self, $request) = @_;
15697  
15698 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15699 my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
15700 return $self->{impl}->listNoteVersions($authenticationToken, $noteGuid);
15701 }
15702  
15703 sub getNoteVersion{
15704 my ($self, $request) = @_;
15705  
15706 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15707 my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
15708 my $updateSequenceNum = ($request->{'updateSequenceNum'}) ? $request->{'updateSequenceNum'} : undef;
15709 my $withResourcesData = ($request->{'withResourcesData'}) ? $request->{'withResourcesData'} : undef;
15710 my $withResourcesRecognition = ($request->{'withResourcesRecognition'}) ? $request->{'withResourcesRecognition'} : undef;
15711 my $withResourcesAlternateData = ($request->{'withResourcesAlternateData'}) ? $request->{'withResourcesAlternateData'} : undef;
15712 return $self->{impl}->getNoteVersion($authenticationToken, $noteGuid, $updateSequenceNum, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
15713 }
15714  
15715 sub getResource{
15716 my ($self, $request) = @_;
15717  
15718 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15719 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15720 my $withData = ($request->{'withData'}) ? $request->{'withData'} : undef;
15721 my $withRecognition = ($request->{'withRecognition'}) ? $request->{'withRecognition'} : undef;
15722 my $withAttributes = ($request->{'withAttributes'}) ? $request->{'withAttributes'} : undef;
15723 my $withAlternateData = ($request->{'withAlternateData'}) ? $request->{'withAlternateData'} : undef;
15724 return $self->{impl}->getResource($authenticationToken, $guid, $withData, $withRecognition, $withAttributes, $withAlternateData);
15725 }
15726  
15727 sub getResourceApplicationData{
15728 my ($self, $request) = @_;
15729  
15730 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15731 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15732 return $self->{impl}->getResourceApplicationData($authenticationToken, $guid);
15733 }
15734  
15735 sub getResourceApplicationDataEntry{
15736 my ($self, $request) = @_;
15737  
15738 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15739 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15740 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15741 return $self->{impl}->getResourceApplicationDataEntry($authenticationToken, $guid, $key);
15742 }
15743  
15744 sub setResourceApplicationDataEntry{
15745 my ($self, $request) = @_;
15746  
15747 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15748 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15749 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15750 my $value = ($request->{'value'}) ? $request->{'value'} : undef;
15751 return $self->{impl}->setResourceApplicationDataEntry($authenticationToken, $guid, $key, $value);
15752 }
15753  
15754 sub unsetResourceApplicationDataEntry{
15755 my ($self, $request) = @_;
15756  
15757 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15758 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15759 my $key = ($request->{'key'}) ? $request->{'key'} : undef;
15760 return $self->{impl}->unsetResourceApplicationDataEntry($authenticationToken, $guid, $key);
15761 }
15762  
15763 sub updateResource{
15764 my ($self, $request) = @_;
15765  
15766 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15767 my $resource = ($request->{'resource'}) ? $request->{'resource'} : undef;
15768 return $self->{impl}->updateResource($authenticationToken, $resource);
15769 }
15770  
15771 sub getResourceData{
15772 my ($self, $request) = @_;
15773  
15774 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15775 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15776 return $self->{impl}->getResourceData($authenticationToken, $guid);
15777 }
15778  
15779 sub getResourceByHash{
15780 my ($self, $request) = @_;
15781  
15782 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15783 my $noteGuid = ($request->{'noteGuid'}) ? $request->{'noteGuid'} : undef;
15784 my $contentHash = ($request->{'contentHash'}) ? $request->{'contentHash'} : undef;
15785 my $withData = ($request->{'withData'}) ? $request->{'withData'} : undef;
15786 my $withRecognition = ($request->{'withRecognition'}) ? $request->{'withRecognition'} : undef;
15787 my $withAlternateData = ($request->{'withAlternateData'}) ? $request->{'withAlternateData'} : undef;
15788 return $self->{impl}->getResourceByHash($authenticationToken, $noteGuid, $contentHash, $withData, $withRecognition, $withAlternateData);
15789 }
15790  
15791 sub getResourceRecognition{
15792 my ($self, $request) = @_;
15793  
15794 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15795 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15796 return $self->{impl}->getResourceRecognition($authenticationToken, $guid);
15797 }
15798  
15799 sub getResourceAlternateData{
15800 my ($self, $request) = @_;
15801  
15802 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15803 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15804 return $self->{impl}->getResourceAlternateData($authenticationToken, $guid);
15805 }
15806  
15807 sub getResourceAttributes{
15808 my ($self, $request) = @_;
15809  
15810 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15811 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15812 return $self->{impl}->getResourceAttributes($authenticationToken, $guid);
15813 }
15814  
15815 sub getAccountSize{
15816 my ($self, $request) = @_;
15817  
15818 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15819 return $self->{impl}->getAccountSize($authenticationToken);
15820 }
15821  
15822 sub getAds{
15823 my ($self, $request) = @_;
15824  
15825 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15826 my $adParameters = ($request->{'adParameters'}) ? $request->{'adParameters'} : undef;
15827 return $self->{impl}->getAds($authenticationToken, $adParameters);
15828 }
15829  
15830 sub getRandomAd{
15831 my ($self, $request) = @_;
15832  
15833 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15834 my $adParameters = ($request->{'adParameters'}) ? $request->{'adParameters'} : undef;
15835 return $self->{impl}->getRandomAd($authenticationToken, $adParameters);
15836 }
15837  
15838 sub getPublicNotebook{
15839 my ($self, $request) = @_;
15840  
15841 my $userId = ($request->{'userId'}) ? $request->{'userId'} : undef;
15842 my $publicUri = ($request->{'publicUri'}) ? $request->{'publicUri'} : undef;
15843 return $self->{impl}->getPublicNotebook($userId, $publicUri);
15844 }
15845  
15846 sub createSharedNotebook{
15847 my ($self, $request) = @_;
15848  
15849 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15850 my $sharedNotebook = ($request->{'sharedNotebook'}) ? $request->{'sharedNotebook'} : undef;
15851 return $self->{impl}->createSharedNotebook($authenticationToken, $sharedNotebook);
15852 }
15853  
15854 sub sendMessageToSharedNotebookMembers{
15855 my ($self, $request) = @_;
15856  
15857 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15858 my $notebookGuid = ($request->{'notebookGuid'}) ? $request->{'notebookGuid'} : undef;
15859 my $messageText = ($request->{'messageText'}) ? $request->{'messageText'} : undef;
15860 my $recipients = ($request->{'recipients'}) ? $request->{'recipients'} : undef;
15861 return $self->{impl}->sendMessageToSharedNotebookMembers($authenticationToken, $notebookGuid, $messageText, $recipients);
15862 }
15863  
15864 sub listSharedNotebooks{
15865 my ($self, $request) = @_;
15866  
15867 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15868 return $self->{impl}->listSharedNotebooks($authenticationToken);
15869 }
15870  
15871 sub expungeSharedNotebooks{
15872 my ($self, $request) = @_;
15873  
15874 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15875 my $sharedNotebookIds = ($request->{'sharedNotebookIds'}) ? $request->{'sharedNotebookIds'} : undef;
15876 return $self->{impl}->expungeSharedNotebooks($authenticationToken, $sharedNotebookIds);
15877 }
15878  
15879 sub createLinkedNotebook{
15880 my ($self, $request) = @_;
15881  
15882 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15883 my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
15884 return $self->{impl}->createLinkedNotebook($authenticationToken, $linkedNotebook);
15885 }
15886  
15887 sub updateLinkedNotebook{
15888 my ($self, $request) = @_;
15889  
15890 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15891 my $linkedNotebook = ($request->{'linkedNotebook'}) ? $request->{'linkedNotebook'} : undef;
15892 return $self->{impl}->updateLinkedNotebook($authenticationToken, $linkedNotebook);
15893 }
15894  
15895 sub listLinkedNotebooks{
15896 my ($self, $request) = @_;
15897  
15898 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15899 return $self->{impl}->listLinkedNotebooks($authenticationToken);
15900 }
15901  
15902 sub expungeLinkedNotebook{
15903 my ($self, $request) = @_;
15904  
15905 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15906 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15907 return $self->{impl}->expungeLinkedNotebook($authenticationToken, $guid);
15908 }
15909  
15910 sub authenticateToSharedNotebook{
15911 my ($self, $request) = @_;
15912  
15913 my $shareKey = ($request->{'shareKey'}) ? $request->{'shareKey'} : undef;
15914 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15915 return $self->{impl}->authenticateToSharedNotebook($shareKey, $authenticationToken);
15916 }
15917  
15918 sub getSharedNotebookByAuth{
15919 my ($self, $request) = @_;
15920  
15921 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15922 return $self->{impl}->getSharedNotebookByAuth($authenticationToken);
15923 }
15924  
15925 sub emailNote{
15926 my ($self, $request) = @_;
15927  
15928 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15929 my $parameters = ($request->{'parameters'}) ? $request->{'parameters'} : undef;
15930 return $self->{impl}->emailNote($authenticationToken, $parameters);
15931 }
15932  
15933 sub shareNote{
15934 my ($self, $request) = @_;
15935  
15936 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15937 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15938 return $self->{impl}->shareNote($authenticationToken, $guid);
15939 }
15940  
15941 sub stopSharingNote{
15942 my ($self, $request) = @_;
15943  
15944 my $authenticationToken = ($request->{'authenticationToken'}) ? $request->{'authenticationToken'} : undef;
15945 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15946 return $self->{impl}->stopSharingNote($authenticationToken, $guid);
15947 }
15948  
15949 sub authenticateToSharedNote{
15950 my ($self, $request) = @_;
15951  
15952 my $guid = ($request->{'guid'}) ? $request->{'guid'} : undef;
15953 my $noteKey = ($request->{'noteKey'}) ? $request->{'noteKey'} : undef;
15954 return $self->{impl}->authenticateToSharedNote($guid, $noteKey);
15955 }
15956  
15957 package Net::Evernote::EDAMNoteStore::NoteStoreClient;
15958  
15959  
15960 use base qw(Net::Evernote::EDAMNoteStore::NoteStoreIf);
15961 sub new {
15962 my ($classname, $input, $output) = @_;
15963 my $self = {};
15964 $self->{input} = $input;
15965 $self->{output} = defined $output ? $output : $input;
15966 $self->{seqid} = 0;
15967 return bless($self,$classname);
15968 }
15969  
15970 sub getSyncState{
15971 my $self = shift;
15972 my $authenticationToken = shift;
15973  
15974 $self->send_getSyncState($authenticationToken);
15975 return $self->recv_getSyncState();
15976 }
15977  
15978 sub send_getSyncState{
15979 my $self = shift;
15980 my $authenticationToken = shift;
15981  
15982 $self->{output}->writeMessageBegin('getSyncState', TMessageType::CALL, $self->{seqid});
15983 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->new();
15984 $args->{authenticationToken} = $authenticationToken;
15985 $args->write($self->{output});
15986 $self->{output}->writeMessageEnd();
15987 $self->{output}->getTransport()->flush();
15988 }
15989  
15990 sub recv_getSyncState{
15991 my $self = shift;
15992  
15993 my $rseqid = 0;
15994 my $fname;
15995 my $mtype = 0;
15996  
15997 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
15998 if ($mtype == TMessageType::EXCEPTION) {
15999 my $x = TApplicationException->new();
16000 $x->read($self->{input});
16001 $self->{input}->readMessageEnd();
16002 die $x;
16003 }
16004 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->new();
16005 $result->read($self->{input});
16006 $self->{input}->readMessageEnd();
16007  
16008 if (defined $result->{success} ) {
16009 return $result->{success};
16010 }
16011 if (defined $result->{userException}) {
16012 die $result->{userException};
16013 }
16014 if (defined $result->{systemException}) {
16015 die $result->{systemException};
16016 }
16017 die "getSyncState failed: unknown result";
16018 }
16019 sub getSyncChunk{
16020 my $self = shift;
16021 my $authenticationToken = shift;
16022 my $afterUSN = shift;
16023 my $maxEntries = shift;
16024 my $fullSyncOnly = shift;
16025  
16026 $self->send_getSyncChunk($authenticationToken, $afterUSN, $maxEntries, $fullSyncOnly);
16027 return $self->recv_getSyncChunk();
16028 }
16029  
16030 sub send_getSyncChunk{
16031 my $self = shift;
16032 my $authenticationToken = shift;
16033 my $afterUSN = shift;
16034 my $maxEntries = shift;
16035 my $fullSyncOnly = shift;
16036  
16037 $self->{output}->writeMessageBegin('getSyncChunk', TMessageType::CALL, $self->{seqid});
16038 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->new();
16039 $args->{authenticationToken} = $authenticationToken;
16040 $args->{afterUSN} = $afterUSN;
16041 $args->{maxEntries} = $maxEntries;
16042 $args->{fullSyncOnly} = $fullSyncOnly;
16043 $args->write($self->{output});
16044 $self->{output}->writeMessageEnd();
16045 $self->{output}->getTransport()->flush();
16046 }
16047  
16048 sub recv_getSyncChunk{
16049 my $self = shift;
16050  
16051 my $rseqid = 0;
16052 my $fname;
16053 my $mtype = 0;
16054  
16055 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16056 if ($mtype == TMessageType::EXCEPTION) {
16057 my $x = TApplicationException->new();
16058 $x->read($self->{input});
16059 $self->{input}->readMessageEnd();
16060 die $x;
16061 }
16062 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->new();
16063 $result->read($self->{input});
16064 $self->{input}->readMessageEnd();
16065  
16066 if (defined $result->{success} ) {
16067 return $result->{success};
16068 }
16069 if (defined $result->{userException}) {
16070 die $result->{userException};
16071 }
16072 if (defined $result->{systemException}) {
16073 die $result->{systemException};
16074 }
16075 die "getSyncChunk failed: unknown result";
16076 }
16077 sub getFilteredSyncChunk{
16078 my $self = shift;
16079 my $authenticationToken = shift;
16080 my $afterUSN = shift;
16081 my $maxEntries = shift;
16082 my $filter = shift;
16083  
16084 $self->send_getFilteredSyncChunk($authenticationToken, $afterUSN, $maxEntries, $filter);
16085 return $self->recv_getFilteredSyncChunk();
16086 }
16087  
16088 sub send_getFilteredSyncChunk{
16089 my $self = shift;
16090 my $authenticationToken = shift;
16091 my $afterUSN = shift;
16092 my $maxEntries = shift;
16093 my $filter = shift;
16094  
16095 $self->{output}->writeMessageBegin('getFilteredSyncChunk', TMessageType::CALL, $self->{seqid});
16096 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->new();
16097 $args->{authenticationToken} = $authenticationToken;
16098 $args->{afterUSN} = $afterUSN;
16099 $args->{maxEntries} = $maxEntries;
16100 $args->{filter} = $filter;
16101 $args->write($self->{output});
16102 $self->{output}->writeMessageEnd();
16103 $self->{output}->getTransport()->flush();
16104 }
16105  
16106 sub recv_getFilteredSyncChunk{
16107 my $self = shift;
16108  
16109 my $rseqid = 0;
16110 my $fname;
16111 my $mtype = 0;
16112  
16113 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16114 if ($mtype == TMessageType::EXCEPTION) {
16115 my $x = TApplicationException->new();
16116 $x->read($self->{input});
16117 $self->{input}->readMessageEnd();
16118 die $x;
16119 }
16120 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->new();
16121 $result->read($self->{input});
16122 $self->{input}->readMessageEnd();
16123  
16124 if (defined $result->{success} ) {
16125 return $result->{success};
16126 }
16127 if (defined $result->{userException}) {
16128 die $result->{userException};
16129 }
16130 if (defined $result->{systemException}) {
16131 die $result->{systemException};
16132 }
16133 die "getFilteredSyncChunk failed: unknown result";
16134 }
16135 sub getLinkedNotebookSyncState{
16136 my $self = shift;
16137 my $authenticationToken = shift;
16138 my $linkedNotebook = shift;
16139  
16140 $self->send_getLinkedNotebookSyncState($authenticationToken, $linkedNotebook);
16141 return $self->recv_getLinkedNotebookSyncState();
16142 }
16143  
16144 sub send_getLinkedNotebookSyncState{
16145 my $self = shift;
16146 my $authenticationToken = shift;
16147 my $linkedNotebook = shift;
16148  
16149 $self->{output}->writeMessageBegin('getLinkedNotebookSyncState', TMessageType::CALL, $self->{seqid});
16150 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->new();
16151 $args->{authenticationToken} = $authenticationToken;
16152 $args->{linkedNotebook} = $linkedNotebook;
16153 $args->write($self->{output});
16154 $self->{output}->writeMessageEnd();
16155 $self->{output}->getTransport()->flush();
16156 }
16157  
16158 sub recv_getLinkedNotebookSyncState{
16159 my $self = shift;
16160  
16161 my $rseqid = 0;
16162 my $fname;
16163 my $mtype = 0;
16164  
16165 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16166 if ($mtype == TMessageType::EXCEPTION) {
16167 my $x = TApplicationException->new();
16168 $x->read($self->{input});
16169 $self->{input}->readMessageEnd();
16170 die $x;
16171 }
16172 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->new();
16173 $result->read($self->{input});
16174 $self->{input}->readMessageEnd();
16175  
16176 if (defined $result->{success} ) {
16177 return $result->{success};
16178 }
16179 if (defined $result->{userException}) {
16180 die $result->{userException};
16181 }
16182 if (defined $result->{systemException}) {
16183 die $result->{systemException};
16184 }
16185 if (defined $result->{notFoundException}) {
16186 die $result->{notFoundException};
16187 }
16188 die "getLinkedNotebookSyncState failed: unknown result";
16189 }
16190 sub getLinkedNotebookSyncChunk{
16191 my $self = shift;
16192 my $authenticationToken = shift;
16193 my $linkedNotebook = shift;
16194 my $afterUSN = shift;
16195 my $maxEntries = shift;
16196 my $fullSyncOnly = shift;
16197  
16198 $self->send_getLinkedNotebookSyncChunk($authenticationToken, $linkedNotebook, $afterUSN, $maxEntries, $fullSyncOnly);
16199 return $self->recv_getLinkedNotebookSyncChunk();
16200 }
16201  
16202 sub send_getLinkedNotebookSyncChunk{
16203 my $self = shift;
16204 my $authenticationToken = shift;
16205 my $linkedNotebook = shift;
16206 my $afterUSN = shift;
16207 my $maxEntries = shift;
16208 my $fullSyncOnly = shift;
16209  
16210 $self->{output}->writeMessageBegin('getLinkedNotebookSyncChunk', TMessageType::CALL, $self->{seqid});
16211 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->new();
16212 $args->{authenticationToken} = $authenticationToken;
16213 $args->{linkedNotebook} = $linkedNotebook;
16214 $args->{afterUSN} = $afterUSN;
16215 $args->{maxEntries} = $maxEntries;
16216 $args->{fullSyncOnly} = $fullSyncOnly;
16217 $args->write($self->{output});
16218 $self->{output}->writeMessageEnd();
16219 $self->{output}->getTransport()->flush();
16220 }
16221  
16222 sub recv_getLinkedNotebookSyncChunk{
16223 my $self = shift;
16224  
16225 my $rseqid = 0;
16226 my $fname;
16227 my $mtype = 0;
16228  
16229 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16230 if ($mtype == TMessageType::EXCEPTION) {
16231 my $x = TApplicationException->new();
16232 $x->read($self->{input});
16233 $self->{input}->readMessageEnd();
16234 die $x;
16235 }
16236 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->new();
16237 $result->read($self->{input});
16238 $self->{input}->readMessageEnd();
16239  
16240 if (defined $result->{success} ) {
16241 return $result->{success};
16242 }
16243 if (defined $result->{userException}) {
16244 die $result->{userException};
16245 }
16246 if (defined $result->{systemException}) {
16247 die $result->{systemException};
16248 }
16249 if (defined $result->{notFoundException}) {
16250 die $result->{notFoundException};
16251 }
16252 die "getLinkedNotebookSyncChunk failed: unknown result";
16253 }
16254 sub listNotebooks{
16255 my $self = shift;
16256 my $authenticationToken = shift;
16257  
16258 $self->send_listNotebooks($authenticationToken);
16259 return $self->recv_listNotebooks();
16260 }
16261  
16262 sub send_listNotebooks{
16263 my $self = shift;
16264 my $authenticationToken = shift;
16265  
16266 $self->{output}->writeMessageBegin('listNotebooks', TMessageType::CALL, $self->{seqid});
16267 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->new();
16268 $args->{authenticationToken} = $authenticationToken;
16269 $args->write($self->{output});
16270 $self->{output}->writeMessageEnd();
16271 $self->{output}->getTransport()->flush();
16272 }
16273  
16274 sub recv_listNotebooks{
16275 my $self = shift;
16276  
16277 my $rseqid = 0;
16278 my $fname;
16279 my $mtype = 0;
16280  
16281 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16282 if ($mtype == TMessageType::EXCEPTION) {
16283 my $x = TApplicationException->new();
16284 $x->read($self->{input});
16285 $self->{input}->readMessageEnd();
16286 die $x;
16287 }
16288 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->new();
16289 $result->read($self->{input});
16290 $self->{input}->readMessageEnd();
16291  
16292 if (defined $result->{success} ) {
16293 return $result->{success};
16294 }
16295 if (defined $result->{userException}) {
16296 die $result->{userException};
16297 }
16298 if (defined $result->{systemException}) {
16299 die $result->{systemException};
16300 }
16301 die "listNotebooks failed: unknown result";
16302 }
16303 sub getNotebook{
16304 my $self = shift;
16305 my $authenticationToken = shift;
16306 my $guid = shift;
16307  
16308 $self->send_getNotebook($authenticationToken, $guid);
16309 return $self->recv_getNotebook();
16310 }
16311  
16312 sub send_getNotebook{
16313 my $self = shift;
16314 my $authenticationToken = shift;
16315 my $guid = shift;
16316  
16317 $self->{output}->writeMessageBegin('getNotebook', TMessageType::CALL, $self->{seqid});
16318 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->new();
16319 $args->{authenticationToken} = $authenticationToken;
16320 $args->{guid} = $guid;
16321 $args->write($self->{output});
16322 $self->{output}->writeMessageEnd();
16323 $self->{output}->getTransport()->flush();
16324 }
16325  
16326 sub recv_getNotebook{
16327 my $self = shift;
16328  
16329 my $rseqid = 0;
16330 my $fname;
16331 my $mtype = 0;
16332  
16333 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16334 if ($mtype == TMessageType::EXCEPTION) {
16335 my $x = TApplicationException->new();
16336 $x->read($self->{input});
16337 $self->{input}->readMessageEnd();
16338 die $x;
16339 }
16340 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->new();
16341 $result->read($self->{input});
16342 $self->{input}->readMessageEnd();
16343  
16344 if (defined $result->{success} ) {
16345 return $result->{success};
16346 }
16347 if (defined $result->{userException}) {
16348 die $result->{userException};
16349 }
16350 if (defined $result->{systemException}) {
16351 die $result->{systemException};
16352 }
16353 if (defined $result->{notFoundException}) {
16354 die $result->{notFoundException};
16355 }
16356 die "getNotebook failed: unknown result";
16357 }
16358 sub getDefaultNotebook{
16359 my $self = shift;
16360 my $authenticationToken = shift;
16361  
16362 $self->send_getDefaultNotebook($authenticationToken);
16363 return $self->recv_getDefaultNotebook();
16364 }
16365  
16366 sub send_getDefaultNotebook{
16367 my $self = shift;
16368 my $authenticationToken = shift;
16369  
16370 $self->{output}->writeMessageBegin('getDefaultNotebook', TMessageType::CALL, $self->{seqid});
16371 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->new();
16372 $args->{authenticationToken} = $authenticationToken;
16373 $args->write($self->{output});
16374 $self->{output}->writeMessageEnd();
16375 $self->{output}->getTransport()->flush();
16376 }
16377  
16378 sub recv_getDefaultNotebook{
16379 my $self = shift;
16380  
16381 my $rseqid = 0;
16382 my $fname;
16383 my $mtype = 0;
16384  
16385 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16386 if ($mtype == TMessageType::EXCEPTION) {
16387 my $x = TApplicationException->new();
16388 $x->read($self->{input});
16389 $self->{input}->readMessageEnd();
16390 die $x;
16391 }
16392 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->new();
16393 $result->read($self->{input});
16394 $self->{input}->readMessageEnd();
16395  
16396 if (defined $result->{success} ) {
16397 return $result->{success};
16398 }
16399 if (defined $result->{userException}) {
16400 die $result->{userException};
16401 }
16402 if (defined $result->{systemException}) {
16403 die $result->{systemException};
16404 }
16405 die "getDefaultNotebook failed: unknown result";
16406 }
16407 sub createNotebook{
16408 my $self = shift;
16409 my $authenticationToken = shift;
16410 my $notebook = shift;
16411  
16412 $self->send_createNotebook($authenticationToken, $notebook);
16413 return $self->recv_createNotebook();
16414 }
16415  
16416 sub send_createNotebook{
16417 my $self = shift;
16418 my $authenticationToken = shift;
16419 my $notebook = shift;
16420  
16421 $self->{output}->writeMessageBegin('createNotebook', TMessageType::CALL, $self->{seqid});
16422 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->new();
16423 $args->{authenticationToken} = $authenticationToken;
16424 $args->{notebook} = $notebook;
16425 $args->write($self->{output});
16426 $self->{output}->writeMessageEnd();
16427 $self->{output}->getTransport()->flush();
16428 }
16429  
16430 sub recv_createNotebook{
16431 my $self = shift;
16432  
16433 my $rseqid = 0;
16434 my $fname;
16435 my $mtype = 0;
16436  
16437 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16438 if ($mtype == TMessageType::EXCEPTION) {
16439 my $x = TApplicationException->new();
16440 $x->read($self->{input});
16441 $self->{input}->readMessageEnd();
16442 die $x;
16443 }
16444 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->new();
16445 $result->read($self->{input});
16446 $self->{input}->readMessageEnd();
16447  
16448 if (defined $result->{success} ) {
16449 return $result->{success};
16450 }
16451 if (defined $result->{userException}) {
16452 die $result->{userException};
16453 }
16454 if (defined $result->{systemException}) {
16455 die $result->{systemException};
16456 }
16457 die "createNotebook failed: unknown result";
16458 }
16459 sub updateNotebook{
16460 my $self = shift;
16461 my $authenticationToken = shift;
16462 my $notebook = shift;
16463  
16464 $self->send_updateNotebook($authenticationToken, $notebook);
16465 return $self->recv_updateNotebook();
16466 }
16467  
16468 sub send_updateNotebook{
16469 my $self = shift;
16470 my $authenticationToken = shift;
16471 my $notebook = shift;
16472  
16473 $self->{output}->writeMessageBegin('updateNotebook', TMessageType::CALL, $self->{seqid});
16474 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->new();
16475 $args->{authenticationToken} = $authenticationToken;
16476 $args->{notebook} = $notebook;
16477 $args->write($self->{output});
16478 $self->{output}->writeMessageEnd();
16479 $self->{output}->getTransport()->flush();
16480 }
16481  
16482 sub recv_updateNotebook{
16483 my $self = shift;
16484  
16485 my $rseqid = 0;
16486 my $fname;
16487 my $mtype = 0;
16488  
16489 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16490 if ($mtype == TMessageType::EXCEPTION) {
16491 my $x = TApplicationException->new();
16492 $x->read($self->{input});
16493 $self->{input}->readMessageEnd();
16494 die $x;
16495 }
16496 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->new();
16497 $result->read($self->{input});
16498 $self->{input}->readMessageEnd();
16499  
16500 if (defined $result->{success} ) {
16501 return $result->{success};
16502 }
16503 if (defined $result->{userException}) {
16504 die $result->{userException};
16505 }
16506 if (defined $result->{systemException}) {
16507 die $result->{systemException};
16508 }
16509 if (defined $result->{notFoundException}) {
16510 die $result->{notFoundException};
16511 }
16512 die "updateNotebook failed: unknown result";
16513 }
16514 sub expungeNotebook{
16515 my $self = shift;
16516 my $authenticationToken = shift;
16517 my $guid = shift;
16518  
16519 $self->send_expungeNotebook($authenticationToken, $guid);
16520 return $self->recv_expungeNotebook();
16521 }
16522  
16523 sub send_expungeNotebook{
16524 my $self = shift;
16525 my $authenticationToken = shift;
16526 my $guid = shift;
16527  
16528 $self->{output}->writeMessageBegin('expungeNotebook', TMessageType::CALL, $self->{seqid});
16529 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->new();
16530 $args->{authenticationToken} = $authenticationToken;
16531 $args->{guid} = $guid;
16532 $args->write($self->{output});
16533 $self->{output}->writeMessageEnd();
16534 $self->{output}->getTransport()->flush();
16535 }
16536  
16537 sub recv_expungeNotebook{
16538 my $self = shift;
16539  
16540 my $rseqid = 0;
16541 my $fname;
16542 my $mtype = 0;
16543  
16544 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16545 if ($mtype == TMessageType::EXCEPTION) {
16546 my $x = TApplicationException->new();
16547 $x->read($self->{input});
16548 $self->{input}->readMessageEnd();
16549 die $x;
16550 }
16551 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->new();
16552 $result->read($self->{input});
16553 $self->{input}->readMessageEnd();
16554  
16555 if (defined $result->{success} ) {
16556 return $result->{success};
16557 }
16558 if (defined $result->{userException}) {
16559 die $result->{userException};
16560 }
16561 if (defined $result->{systemException}) {
16562 die $result->{systemException};
16563 }
16564 if (defined $result->{notFoundException}) {
16565 die $result->{notFoundException};
16566 }
16567 die "expungeNotebook failed: unknown result";
16568 }
16569 sub listTags{
16570 my $self = shift;
16571 my $authenticationToken = shift;
16572  
16573 $self->send_listTags($authenticationToken);
16574 return $self->recv_listTags();
16575 }
16576  
16577 sub send_listTags{
16578 my $self = shift;
16579 my $authenticationToken = shift;
16580  
16581 $self->{output}->writeMessageBegin('listTags', TMessageType::CALL, $self->{seqid});
16582 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->new();
16583 $args->{authenticationToken} = $authenticationToken;
16584 $args->write($self->{output});
16585 $self->{output}->writeMessageEnd();
16586 $self->{output}->getTransport()->flush();
16587 }
16588  
16589 sub recv_listTags{
16590 my $self = shift;
16591  
16592 my $rseqid = 0;
16593 my $fname;
16594 my $mtype = 0;
16595  
16596 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16597 if ($mtype == TMessageType::EXCEPTION) {
16598 my $x = TApplicationException->new();
16599 $x->read($self->{input});
16600 $self->{input}->readMessageEnd();
16601 die $x;
16602 }
16603 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->new();
16604 $result->read($self->{input});
16605 $self->{input}->readMessageEnd();
16606  
16607 if (defined $result->{success} ) {
16608 return $result->{success};
16609 }
16610 if (defined $result->{userException}) {
16611 die $result->{userException};
16612 }
16613 if (defined $result->{systemException}) {
16614 die $result->{systemException};
16615 }
16616 die "listTags failed: unknown result";
16617 }
16618 sub listTagsByNotebook{
16619 my $self = shift;
16620 my $authenticationToken = shift;
16621 my $notebookGuid = shift;
16622  
16623 $self->send_listTagsByNotebook($authenticationToken, $notebookGuid);
16624 return $self->recv_listTagsByNotebook();
16625 }
16626  
16627 sub send_listTagsByNotebook{
16628 my $self = shift;
16629 my $authenticationToken = shift;
16630 my $notebookGuid = shift;
16631  
16632 $self->{output}->writeMessageBegin('listTagsByNotebook', TMessageType::CALL, $self->{seqid});
16633 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->new();
16634 $args->{authenticationToken} = $authenticationToken;
16635 $args->{notebookGuid} = $notebookGuid;
16636 $args->write($self->{output});
16637 $self->{output}->writeMessageEnd();
16638 $self->{output}->getTransport()->flush();
16639 }
16640  
16641 sub recv_listTagsByNotebook{
16642 my $self = shift;
16643  
16644 my $rseqid = 0;
16645 my $fname;
16646 my $mtype = 0;
16647  
16648 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16649 if ($mtype == TMessageType::EXCEPTION) {
16650 my $x = TApplicationException->new();
16651 $x->read($self->{input});
16652 $self->{input}->readMessageEnd();
16653 die $x;
16654 }
16655 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->new();
16656 $result->read($self->{input});
16657 $self->{input}->readMessageEnd();
16658  
16659 if (defined $result->{success} ) {
16660 return $result->{success};
16661 }
16662 if (defined $result->{userException}) {
16663 die $result->{userException};
16664 }
16665 if (defined $result->{systemException}) {
16666 die $result->{systemException};
16667 }
16668 if (defined $result->{notFoundException}) {
16669 die $result->{notFoundException};
16670 }
16671 die "listTagsByNotebook failed: unknown result";
16672 }
16673 sub getTag{
16674 my $self = shift;
16675 my $authenticationToken = shift;
16676 my $guid = shift;
16677  
16678 $self->send_getTag($authenticationToken, $guid);
16679 return $self->recv_getTag();
16680 }
16681  
16682 sub send_getTag{
16683 my $self = shift;
16684 my $authenticationToken = shift;
16685 my $guid = shift;
16686  
16687 $self->{output}->writeMessageBegin('getTag', TMessageType::CALL, $self->{seqid});
16688 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->new();
16689 $args->{authenticationToken} = $authenticationToken;
16690 $args->{guid} = $guid;
16691 $args->write($self->{output});
16692 $self->{output}->writeMessageEnd();
16693 $self->{output}->getTransport()->flush();
16694 }
16695  
16696 sub recv_getTag{
16697 my $self = shift;
16698  
16699 my $rseqid = 0;
16700 my $fname;
16701 my $mtype = 0;
16702  
16703 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16704 if ($mtype == TMessageType::EXCEPTION) {
16705 my $x = TApplicationException->new();
16706 $x->read($self->{input});
16707 $self->{input}->readMessageEnd();
16708 die $x;
16709 }
16710 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->new();
16711 $result->read($self->{input});
16712 $self->{input}->readMessageEnd();
16713  
16714 if (defined $result->{success} ) {
16715 return $result->{success};
16716 }
16717 if (defined $result->{userException}) {
16718 die $result->{userException};
16719 }
16720 if (defined $result->{systemException}) {
16721 die $result->{systemException};
16722 }
16723 if (defined $result->{notFoundException}) {
16724 die $result->{notFoundException};
16725 }
16726 die "getTag failed: unknown result";
16727 }
16728 sub createTag{
16729 my $self = shift;
16730 my $authenticationToken = shift;
16731 my $tag = shift;
16732  
16733 $self->send_createTag($authenticationToken, $tag);
16734 return $self->recv_createTag();
16735 }
16736  
16737 sub send_createTag{
16738 my $self = shift;
16739 my $authenticationToken = shift;
16740 my $tag = shift;
16741  
16742 $self->{output}->writeMessageBegin('createTag', TMessageType::CALL, $self->{seqid});
16743 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->new();
16744 $args->{authenticationToken} = $authenticationToken;
16745 $args->{tag} = $tag;
16746 $args->write($self->{output});
16747 $self->{output}->writeMessageEnd();
16748 $self->{output}->getTransport()->flush();
16749 }
16750  
16751 sub recv_createTag{
16752 my $self = shift;
16753  
16754 my $rseqid = 0;
16755 my $fname;
16756 my $mtype = 0;
16757  
16758 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16759 if ($mtype == TMessageType::EXCEPTION) {
16760 my $x = TApplicationException->new();
16761 $x->read($self->{input});
16762 $self->{input}->readMessageEnd();
16763 die $x;
16764 }
16765 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->new();
16766 $result->read($self->{input});
16767 $self->{input}->readMessageEnd();
16768  
16769 if (defined $result->{success} ) {
16770 return $result->{success};
16771 }
16772 if (defined $result->{userException}) {
16773 die $result->{userException};
16774 }
16775 if (defined $result->{systemException}) {
16776 die $result->{systemException};
16777 }
16778 if (defined $result->{notFoundException}) {
16779 die $result->{notFoundException};
16780 }
16781 die "createTag failed: unknown result";
16782 }
16783 sub updateTag{
16784 my $self = shift;
16785 my $authenticationToken = shift;
16786 my $tag = shift;
16787  
16788 $self->send_updateTag($authenticationToken, $tag);
16789 return $self->recv_updateTag();
16790 }
16791  
16792 sub send_updateTag{
16793 my $self = shift;
16794 my $authenticationToken = shift;
16795 my $tag = shift;
16796  
16797 $self->{output}->writeMessageBegin('updateTag', TMessageType::CALL, $self->{seqid});
16798 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->new();
16799 $args->{authenticationToken} = $authenticationToken;
16800 $args->{tag} = $tag;
16801 $args->write($self->{output});
16802 $self->{output}->writeMessageEnd();
16803 $self->{output}->getTransport()->flush();
16804 }
16805  
16806 sub recv_updateTag{
16807 my $self = shift;
16808  
16809 my $rseqid = 0;
16810 my $fname;
16811 my $mtype = 0;
16812  
16813 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16814 if ($mtype == TMessageType::EXCEPTION) {
16815 my $x = TApplicationException->new();
16816 $x->read($self->{input});
16817 $self->{input}->readMessageEnd();
16818 die $x;
16819 }
16820 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->new();
16821 $result->read($self->{input});
16822 $self->{input}->readMessageEnd();
16823  
16824 if (defined $result->{success} ) {
16825 return $result->{success};
16826 }
16827 if (defined $result->{userException}) {
16828 die $result->{userException};
16829 }
16830 if (defined $result->{systemException}) {
16831 die $result->{systemException};
16832 }
16833 if (defined $result->{notFoundException}) {
16834 die $result->{notFoundException};
16835 }
16836 die "updateTag failed: unknown result";
16837 }
16838 sub untagAll{
16839 my $self = shift;
16840 my $authenticationToken = shift;
16841 my $guid = shift;
16842  
16843 $self->send_untagAll($authenticationToken, $guid);
16844 $self->recv_untagAll();
16845 }
16846  
16847 sub send_untagAll{
16848 my $self = shift;
16849 my $authenticationToken = shift;
16850 my $guid = shift;
16851  
16852 $self->{output}->writeMessageBegin('untagAll', TMessageType::CALL, $self->{seqid});
16853 my $args = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->new();
16854 $args->{authenticationToken} = $authenticationToken;
16855 $args->{guid} = $guid;
16856 $args->write($self->{output});
16857 $self->{output}->writeMessageEnd();
16858 $self->{output}->getTransport()->flush();
16859 }
16860  
16861 sub recv_untagAll{
16862 my $self = shift;
16863  
16864 my $rseqid = 0;
16865 my $fname;
16866 my $mtype = 0;
16867  
16868 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16869 if ($mtype == TMessageType::EXCEPTION) {
16870 my $x = TApplicationException->new();
16871 $x->read($self->{input});
16872 $self->{input}->readMessageEnd();
16873 die $x;
16874 }
16875 my $result = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->new();
16876 $result->read($self->{input});
16877 $self->{input}->readMessageEnd();
16878  
16879 if (defined $result->{userException}) {
16880 die $result->{userException};
16881 }
16882 if (defined $result->{systemException}) {
16883 die $result->{systemException};
16884 }
16885 if (defined $result->{notFoundException}) {
16886 die $result->{notFoundException};
16887 }
16888 return;
16889 }
16890 sub expungeTag{
16891 my $self = shift;
16892 my $authenticationToken = shift;
16893 my $guid = shift;
16894  
16895 $self->send_expungeTag($authenticationToken, $guid);
16896 return $self->recv_expungeTag();
16897 }
16898  
16899 sub send_expungeTag{
16900 my $self = shift;
16901 my $authenticationToken = shift;
16902 my $guid = shift;
16903  
16904 $self->{output}->writeMessageBegin('expungeTag', TMessageType::CALL, $self->{seqid});
16905 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->new();
16906 $args->{authenticationToken} = $authenticationToken;
16907 $args->{guid} = $guid;
16908 $args->write($self->{output});
16909 $self->{output}->writeMessageEnd();
16910 $self->{output}->getTransport()->flush();
16911 }
16912  
16913 sub recv_expungeTag{
16914 my $self = shift;
16915  
16916 my $rseqid = 0;
16917 my $fname;
16918 my $mtype = 0;
16919  
16920 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16921 if ($mtype == TMessageType::EXCEPTION) {
16922 my $x = TApplicationException->new();
16923 $x->read($self->{input});
16924 $self->{input}->readMessageEnd();
16925 die $x;
16926 }
16927 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->new();
16928 $result->read($self->{input});
16929 $self->{input}->readMessageEnd();
16930  
16931 if (defined $result->{success} ) {
16932 return $result->{success};
16933 }
16934 if (defined $result->{userException}) {
16935 die $result->{userException};
16936 }
16937 if (defined $result->{systemException}) {
16938 die $result->{systemException};
16939 }
16940 if (defined $result->{notFoundException}) {
16941 die $result->{notFoundException};
16942 }
16943 die "expungeTag failed: unknown result";
16944 }
16945 sub listSearches{
16946 my $self = shift;
16947 my $authenticationToken = shift;
16948  
16949 $self->send_listSearches($authenticationToken);
16950 return $self->recv_listSearches();
16951 }
16952  
16953 sub send_listSearches{
16954 my $self = shift;
16955 my $authenticationToken = shift;
16956  
16957 $self->{output}->writeMessageBegin('listSearches', TMessageType::CALL, $self->{seqid});
16958 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->new();
16959 $args->{authenticationToken} = $authenticationToken;
16960 $args->write($self->{output});
16961 $self->{output}->writeMessageEnd();
16962 $self->{output}->getTransport()->flush();
16963 }
16964  
16965 sub recv_listSearches{
16966 my $self = shift;
16967  
16968 my $rseqid = 0;
16969 my $fname;
16970 my $mtype = 0;
16971  
16972 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
16973 if ($mtype == TMessageType::EXCEPTION) {
16974 my $x = TApplicationException->new();
16975 $x->read($self->{input});
16976 $self->{input}->readMessageEnd();
16977 die $x;
16978 }
16979 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->new();
16980 $result->read($self->{input});
16981 $self->{input}->readMessageEnd();
16982  
16983 if (defined $result->{success} ) {
16984 return $result->{success};
16985 }
16986 if (defined $result->{userException}) {
16987 die $result->{userException};
16988 }
16989 if (defined $result->{systemException}) {
16990 die $result->{systemException};
16991 }
16992 die "listSearches failed: unknown result";
16993 }
16994 sub getSearch{
16995 my $self = shift;
16996 my $authenticationToken = shift;
16997 my $guid = shift;
16998  
16999 $self->send_getSearch($authenticationToken, $guid);
17000 return $self->recv_getSearch();
17001 }
17002  
17003 sub send_getSearch{
17004 my $self = shift;
17005 my $authenticationToken = shift;
17006 my $guid = shift;
17007  
17008 $self->{output}->writeMessageBegin('getSearch', TMessageType::CALL, $self->{seqid});
17009 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->new();
17010 $args->{authenticationToken} = $authenticationToken;
17011 $args->{guid} = $guid;
17012 $args->write($self->{output});
17013 $self->{output}->writeMessageEnd();
17014 $self->{output}->getTransport()->flush();
17015 }
17016  
17017 sub recv_getSearch{
17018 my $self = shift;
17019  
17020 my $rseqid = 0;
17021 my $fname;
17022 my $mtype = 0;
17023  
17024 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17025 if ($mtype == TMessageType::EXCEPTION) {
17026 my $x = TApplicationException->new();
17027 $x->read($self->{input});
17028 $self->{input}->readMessageEnd();
17029 die $x;
17030 }
17031 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->new();
17032 $result->read($self->{input});
17033 $self->{input}->readMessageEnd();
17034  
17035 if (defined $result->{success} ) {
17036 return $result->{success};
17037 }
17038 if (defined $result->{userException}) {
17039 die $result->{userException};
17040 }
17041 if (defined $result->{systemException}) {
17042 die $result->{systemException};
17043 }
17044 if (defined $result->{notFoundException}) {
17045 die $result->{notFoundException};
17046 }
17047 die "getSearch failed: unknown result";
17048 }
17049 sub createSearch{
17050 my $self = shift;
17051 my $authenticationToken = shift;
17052 my $search = shift;
17053  
17054 $self->send_createSearch($authenticationToken, $search);
17055 return $self->recv_createSearch();
17056 }
17057  
17058 sub send_createSearch{
17059 my $self = shift;
17060 my $authenticationToken = shift;
17061 my $search = shift;
17062  
17063 $self->{output}->writeMessageBegin('createSearch', TMessageType::CALL, $self->{seqid});
17064 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->new();
17065 $args->{authenticationToken} = $authenticationToken;
17066 $args->{search} = $search;
17067 $args->write($self->{output});
17068 $self->{output}->writeMessageEnd();
17069 $self->{output}->getTransport()->flush();
17070 }
17071  
17072 sub recv_createSearch{
17073 my $self = shift;
17074  
17075 my $rseqid = 0;
17076 my $fname;
17077 my $mtype = 0;
17078  
17079 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17080 if ($mtype == TMessageType::EXCEPTION) {
17081 my $x = TApplicationException->new();
17082 $x->read($self->{input});
17083 $self->{input}->readMessageEnd();
17084 die $x;
17085 }
17086 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->new();
17087 $result->read($self->{input});
17088 $self->{input}->readMessageEnd();
17089  
17090 if (defined $result->{success} ) {
17091 return $result->{success};
17092 }
17093 if (defined $result->{userException}) {
17094 die $result->{userException};
17095 }
17096 if (defined $result->{systemException}) {
17097 die $result->{systemException};
17098 }
17099 die "createSearch failed: unknown result";
17100 }
17101 sub updateSearch{
17102 my $self = shift;
17103 my $authenticationToken = shift;
17104 my $search = shift;
17105  
17106 $self->send_updateSearch($authenticationToken, $search);
17107 return $self->recv_updateSearch();
17108 }
17109  
17110 sub send_updateSearch{
17111 my $self = shift;
17112 my $authenticationToken = shift;
17113 my $search = shift;
17114  
17115 $self->{output}->writeMessageBegin('updateSearch', TMessageType::CALL, $self->{seqid});
17116 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->new();
17117 $args->{authenticationToken} = $authenticationToken;
17118 $args->{search} = $search;
17119 $args->write($self->{output});
17120 $self->{output}->writeMessageEnd();
17121 $self->{output}->getTransport()->flush();
17122 }
17123  
17124 sub recv_updateSearch{
17125 my $self = shift;
17126  
17127 my $rseqid = 0;
17128 my $fname;
17129 my $mtype = 0;
17130  
17131 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17132 if ($mtype == TMessageType::EXCEPTION) {
17133 my $x = TApplicationException->new();
17134 $x->read($self->{input});
17135 $self->{input}->readMessageEnd();
17136 die $x;
17137 }
17138 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->new();
17139 $result->read($self->{input});
17140 $self->{input}->readMessageEnd();
17141  
17142 if (defined $result->{success} ) {
17143 return $result->{success};
17144 }
17145 if (defined $result->{userException}) {
17146 die $result->{userException};
17147 }
17148 if (defined $result->{systemException}) {
17149 die $result->{systemException};
17150 }
17151 if (defined $result->{notFoundException}) {
17152 die $result->{notFoundException};
17153 }
17154 die "updateSearch failed: unknown result";
17155 }
17156 sub expungeSearch{
17157 my $self = shift;
17158 my $authenticationToken = shift;
17159 my $guid = shift;
17160  
17161 $self->send_expungeSearch($authenticationToken, $guid);
17162 return $self->recv_expungeSearch();
17163 }
17164  
17165 sub send_expungeSearch{
17166 my $self = shift;
17167 my $authenticationToken = shift;
17168 my $guid = shift;
17169  
17170 $self->{output}->writeMessageBegin('expungeSearch', TMessageType::CALL, $self->{seqid});
17171 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->new();
17172 $args->{authenticationToken} = $authenticationToken;
17173 $args->{guid} = $guid;
17174 $args->write($self->{output});
17175 $self->{output}->writeMessageEnd();
17176 $self->{output}->getTransport()->flush();
17177 }
17178  
17179 sub recv_expungeSearch{
17180 my $self = shift;
17181  
17182 my $rseqid = 0;
17183 my $fname;
17184 my $mtype = 0;
17185  
17186 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17187 if ($mtype == TMessageType::EXCEPTION) {
17188 my $x = TApplicationException->new();
17189 $x->read($self->{input});
17190 $self->{input}->readMessageEnd();
17191 die $x;
17192 }
17193 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->new();
17194 $result->read($self->{input});
17195 $self->{input}->readMessageEnd();
17196  
17197 if (defined $result->{success} ) {
17198 return $result->{success};
17199 }
17200 if (defined $result->{userException}) {
17201 die $result->{userException};
17202 }
17203 if (defined $result->{systemException}) {
17204 die $result->{systemException};
17205 }
17206 if (defined $result->{notFoundException}) {
17207 die $result->{notFoundException};
17208 }
17209 die "expungeSearch failed: unknown result";
17210 }
17211 sub findNotes{
17212 my $self = shift;
17213 my $authenticationToken = shift;
17214 my $filter = shift;
17215 my $offset = shift;
17216 my $maxNotes = shift;
17217  
17218 $self->send_findNotes($authenticationToken, $filter, $offset, $maxNotes);
17219 return $self->recv_findNotes();
17220 }
17221  
17222 sub send_findNotes{
17223 my $self = shift;
17224 my $authenticationToken = shift;
17225 my $filter = shift;
17226 my $offset = shift;
17227 my $maxNotes = shift;
17228  
17229 $self->{output}->writeMessageBegin('findNotes', TMessageType::CALL, $self->{seqid});
17230 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->new();
17231 $args->{authenticationToken} = $authenticationToken;
17232 $args->{filter} = $filter;
17233 $args->{offset} = $offset;
17234 $args->{maxNotes} = $maxNotes;
17235 $args->write($self->{output});
17236 $self->{output}->writeMessageEnd();
17237 $self->{output}->getTransport()->flush();
17238 }
17239  
17240 sub recv_findNotes{
17241 my $self = shift;
17242  
17243 my $rseqid = 0;
17244 my $fname;
17245 my $mtype = 0;
17246  
17247 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17248 if ($mtype == TMessageType::EXCEPTION) {
17249 my $x = TApplicationException->new();
17250 $x->read($self->{input});
17251 $self->{input}->readMessageEnd();
17252 die $x;
17253 }
17254 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->new();
17255 $result->read($self->{input});
17256 $self->{input}->readMessageEnd();
17257  
17258 if (defined $result->{success} ) {
17259 return $result->{success};
17260 }
17261 if (defined $result->{userException}) {
17262 die $result->{userException};
17263 }
17264 if (defined $result->{systemException}) {
17265 die $result->{systemException};
17266 }
17267 if (defined $result->{notFoundException}) {
17268 die $result->{notFoundException};
17269 }
17270 die "findNotes failed: unknown result";
17271 }
17272 sub findNoteOffset{
17273 my $self = shift;
17274 my $authenticationToken = shift;
17275 my $filter = shift;
17276 my $guid = shift;
17277  
17278 $self->send_findNoteOffset($authenticationToken, $filter, $guid);
17279 return $self->recv_findNoteOffset();
17280 }
17281  
17282 sub send_findNoteOffset{
17283 my $self = shift;
17284 my $authenticationToken = shift;
17285 my $filter = shift;
17286 my $guid = shift;
17287  
17288 $self->{output}->writeMessageBegin('findNoteOffset', TMessageType::CALL, $self->{seqid});
17289 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->new();
17290 $args->{authenticationToken} = $authenticationToken;
17291 $args->{filter} = $filter;
17292 $args->{guid} = $guid;
17293 $args->write($self->{output});
17294 $self->{output}->writeMessageEnd();
17295 $self->{output}->getTransport()->flush();
17296 }
17297  
17298 sub recv_findNoteOffset{
17299 my $self = shift;
17300  
17301 my $rseqid = 0;
17302 my $fname;
17303 my $mtype = 0;
17304  
17305 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17306 if ($mtype == TMessageType::EXCEPTION) {
17307 my $x = TApplicationException->new();
17308 $x->read($self->{input});
17309 $self->{input}->readMessageEnd();
17310 die $x;
17311 }
17312 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->new();
17313 $result->read($self->{input});
17314 $self->{input}->readMessageEnd();
17315  
17316 if (defined $result->{success} ) {
17317 return $result->{success};
17318 }
17319 if (defined $result->{userException}) {
17320 die $result->{userException};
17321 }
17322 if (defined $result->{systemException}) {
17323 die $result->{systemException};
17324 }
17325 if (defined $result->{notFoundException}) {
17326 die $result->{notFoundException};
17327 }
17328 die "findNoteOffset failed: unknown result";
17329 }
17330 sub findNotesMetadata{
17331 my $self = shift;
17332 my $authenticationToken = shift;
17333 my $filter = shift;
17334 my $offset = shift;
17335 my $maxNotes = shift;
17336 my $resultSpec = shift;
17337  
17338 $self->send_findNotesMetadata($authenticationToken, $filter, $offset, $maxNotes, $resultSpec);
17339 return $self->recv_findNotesMetadata();
17340 }
17341  
17342 sub send_findNotesMetadata{
17343 my $self = shift;
17344 my $authenticationToken = shift;
17345 my $filter = shift;
17346 my $offset = shift;
17347 my $maxNotes = shift;
17348 my $resultSpec = shift;
17349  
17350 $self->{output}->writeMessageBegin('findNotesMetadata', TMessageType::CALL, $self->{seqid});
17351 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->new();
17352 $args->{authenticationToken} = $authenticationToken;
17353 $args->{filter} = $filter;
17354 $args->{offset} = $offset;
17355 $args->{maxNotes} = $maxNotes;
17356 $args->{resultSpec} = $resultSpec;
17357 $args->write($self->{output});
17358 $self->{output}->writeMessageEnd();
17359 $self->{output}->getTransport()->flush();
17360 }
17361  
17362 sub recv_findNotesMetadata{
17363 my $self = shift;
17364  
17365 my $rseqid = 0;
17366 my $fname;
17367 my $mtype = 0;
17368  
17369 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17370 if ($mtype == TMessageType::EXCEPTION) {
17371 my $x = TApplicationException->new();
17372 $x->read($self->{input});
17373 $self->{input}->readMessageEnd();
17374 die $x;
17375 }
17376 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->new();
17377 $result->read($self->{input});
17378 $self->{input}->readMessageEnd();
17379  
17380 if (defined $result->{success} ) {
17381 return $result->{success};
17382 }
17383 if (defined $result->{userException}) {
17384 die $result->{userException};
17385 }
17386 if (defined $result->{systemException}) {
17387 die $result->{systemException};
17388 }
17389 if (defined $result->{notFoundException}) {
17390 die $result->{notFoundException};
17391 }
17392 die "findNotesMetadata failed: unknown result";
17393 }
17394 sub findNoteCounts{
17395 my $self = shift;
17396 my $authenticationToken = shift;
17397 my $filter = shift;
17398 my $withTrash = shift;
17399  
17400 $self->send_findNoteCounts($authenticationToken, $filter, $withTrash);
17401 return $self->recv_findNoteCounts();
17402 }
17403  
17404 sub send_findNoteCounts{
17405 my $self = shift;
17406 my $authenticationToken = shift;
17407 my $filter = shift;
17408 my $withTrash = shift;
17409  
17410 $self->{output}->writeMessageBegin('findNoteCounts', TMessageType::CALL, $self->{seqid});
17411 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->new();
17412 $args->{authenticationToken} = $authenticationToken;
17413 $args->{filter} = $filter;
17414 $args->{withTrash} = $withTrash;
17415 $args->write($self->{output});
17416 $self->{output}->writeMessageEnd();
17417 $self->{output}->getTransport()->flush();
17418 }
17419  
17420 sub recv_findNoteCounts{
17421 my $self = shift;
17422  
17423 my $rseqid = 0;
17424 my $fname;
17425 my $mtype = 0;
17426  
17427 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17428 if ($mtype == TMessageType::EXCEPTION) {
17429 my $x = TApplicationException->new();
17430 $x->read($self->{input});
17431 $self->{input}->readMessageEnd();
17432 die $x;
17433 }
17434 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->new();
17435 $result->read($self->{input});
17436 $self->{input}->readMessageEnd();
17437  
17438 if (defined $result->{success} ) {
17439 return $result->{success};
17440 }
17441 if (defined $result->{userException}) {
17442 die $result->{userException};
17443 }
17444 if (defined $result->{systemException}) {
17445 die $result->{systemException};
17446 }
17447 if (defined $result->{notFoundException}) {
17448 die $result->{notFoundException};
17449 }
17450 die "findNoteCounts failed: unknown result";
17451 }
17452 sub getNote{
17453 my $self = shift;
17454 my $authenticationToken = shift;
17455 my $guid = shift;
17456 my $withContent = shift;
17457 my $withResourcesData = shift;
17458 my $withResourcesRecognition = shift;
17459 my $withResourcesAlternateData = shift;
17460  
17461 $self->send_getNote($authenticationToken, $guid, $withContent, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
17462 return $self->recv_getNote();
17463 }
17464  
17465 sub send_getNote{
17466 my $self = shift;
17467 my $authenticationToken = shift;
17468 my $guid = shift;
17469 my $withContent = shift;
17470 my $withResourcesData = shift;
17471 my $withResourcesRecognition = shift;
17472 my $withResourcesAlternateData = shift;
17473  
17474 $self->{output}->writeMessageBegin('getNote', TMessageType::CALL, $self->{seqid});
17475 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->new();
17476 $args->{authenticationToken} = $authenticationToken;
17477 $args->{guid} = $guid;
17478 $args->{withContent} = $withContent;
17479 $args->{withResourcesData} = $withResourcesData;
17480 $args->{withResourcesRecognition} = $withResourcesRecognition;
17481 $args->{withResourcesAlternateData} = $withResourcesAlternateData;
17482 $args->write($self->{output});
17483 $self->{output}->writeMessageEnd();
17484 $self->{output}->getTransport()->flush();
17485 }
17486  
17487 sub recv_getNote{
17488 my $self = shift;
17489  
17490 my $rseqid = 0;
17491 my $fname;
17492 my $mtype = 0;
17493  
17494 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17495 if ($mtype == TMessageType::EXCEPTION) {
17496 my $x = TApplicationException->new();
17497 $x->read($self->{input});
17498 $self->{input}->readMessageEnd();
17499 die $x;
17500 }
17501 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->new();
17502 $result->read($self->{input});
17503 $self->{input}->readMessageEnd();
17504  
17505 if (defined $result->{success} ) {
17506 return $result->{success};
17507 }
17508 if (defined $result->{userException}) {
17509 die $result->{userException};
17510 }
17511 if (defined $result->{systemException}) {
17512 die $result->{systemException};
17513 }
17514 if (defined $result->{notFoundException}) {
17515 die $result->{notFoundException};
17516 }
17517 die "getNote failed: unknown result";
17518 }
17519 sub getNoteApplicationData{
17520 my $self = shift;
17521 my $authenticationToken = shift;
17522 my $guid = shift;
17523  
17524 $self->send_getNoteApplicationData($authenticationToken, $guid);
17525 return $self->recv_getNoteApplicationData();
17526 }
17527  
17528 sub send_getNoteApplicationData{
17529 my $self = shift;
17530 my $authenticationToken = shift;
17531 my $guid = shift;
17532  
17533 $self->{output}->writeMessageBegin('getNoteApplicationData', TMessageType::CALL, $self->{seqid});
17534 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->new();
17535 $args->{authenticationToken} = $authenticationToken;
17536 $args->{guid} = $guid;
17537 $args->write($self->{output});
17538 $self->{output}->writeMessageEnd();
17539 $self->{output}->getTransport()->flush();
17540 }
17541  
17542 sub recv_getNoteApplicationData{
17543 my $self = shift;
17544  
17545 my $rseqid = 0;
17546 my $fname;
17547 my $mtype = 0;
17548  
17549 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17550 if ($mtype == TMessageType::EXCEPTION) {
17551 my $x = TApplicationException->new();
17552 $x->read($self->{input});
17553 $self->{input}->readMessageEnd();
17554 die $x;
17555 }
17556 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->new();
17557 $result->read($self->{input});
17558 $self->{input}->readMessageEnd();
17559  
17560 if (defined $result->{success} ) {
17561 return $result->{success};
17562 }
17563 if (defined $result->{userException}) {
17564 die $result->{userException};
17565 }
17566 if (defined $result->{systemException}) {
17567 die $result->{systemException};
17568 }
17569 if (defined $result->{notFoundException}) {
17570 die $result->{notFoundException};
17571 }
17572 die "getNoteApplicationData failed: unknown result";
17573 }
17574 sub getNoteApplicationDataEntry{
17575 my $self = shift;
17576 my $authenticationToken = shift;
17577 my $guid = shift;
17578 my $key = shift;
17579  
17580 $self->send_getNoteApplicationDataEntry($authenticationToken, $guid, $key);
17581 return $self->recv_getNoteApplicationDataEntry();
17582 }
17583  
17584 sub send_getNoteApplicationDataEntry{
17585 my $self = shift;
17586 my $authenticationToken = shift;
17587 my $guid = shift;
17588 my $key = shift;
17589  
17590 $self->{output}->writeMessageBegin('getNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
17591 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->new();
17592 $args->{authenticationToken} = $authenticationToken;
17593 $args->{guid} = $guid;
17594 $args->{key} = $key;
17595 $args->write($self->{output});
17596 $self->{output}->writeMessageEnd();
17597 $self->{output}->getTransport()->flush();
17598 }
17599  
17600 sub recv_getNoteApplicationDataEntry{
17601 my $self = shift;
17602  
17603 my $rseqid = 0;
17604 my $fname;
17605 my $mtype = 0;
17606  
17607 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17608 if ($mtype == TMessageType::EXCEPTION) {
17609 my $x = TApplicationException->new();
17610 $x->read($self->{input});
17611 $self->{input}->readMessageEnd();
17612 die $x;
17613 }
17614 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->new();
17615 $result->read($self->{input});
17616 $self->{input}->readMessageEnd();
17617  
17618 if (defined $result->{success} ) {
17619 return $result->{success};
17620 }
17621 if (defined $result->{userException}) {
17622 die $result->{userException};
17623 }
17624 if (defined $result->{systemException}) {
17625 die $result->{systemException};
17626 }
17627 if (defined $result->{notFoundException}) {
17628 die $result->{notFoundException};
17629 }
17630 die "getNoteApplicationDataEntry failed: unknown result";
17631 }
17632 sub setNoteApplicationDataEntry{
17633 my $self = shift;
17634 my $authenticationToken = shift;
17635 my $guid = shift;
17636 my $key = shift;
17637 my $value = shift;
17638  
17639 $self->send_setNoteApplicationDataEntry($authenticationToken, $guid, $key, $value);
17640 return $self->recv_setNoteApplicationDataEntry();
17641 }
17642  
17643 sub send_setNoteApplicationDataEntry{
17644 my $self = shift;
17645 my $authenticationToken = shift;
17646 my $guid = shift;
17647 my $key = shift;
17648 my $value = shift;
17649  
17650 $self->{output}->writeMessageBegin('setNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
17651 my $args = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->new();
17652 $args->{authenticationToken} = $authenticationToken;
17653 $args->{guid} = $guid;
17654 $args->{key} = $key;
17655 $args->{value} = $value;
17656 $args->write($self->{output});
17657 $self->{output}->writeMessageEnd();
17658 $self->{output}->getTransport()->flush();
17659 }
17660  
17661 sub recv_setNoteApplicationDataEntry{
17662 my $self = shift;
17663  
17664 my $rseqid = 0;
17665 my $fname;
17666 my $mtype = 0;
17667  
17668 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17669 if ($mtype == TMessageType::EXCEPTION) {
17670 my $x = TApplicationException->new();
17671 $x->read($self->{input});
17672 $self->{input}->readMessageEnd();
17673 die $x;
17674 }
17675 my $result = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->new();
17676 $result->read($self->{input});
17677 $self->{input}->readMessageEnd();
17678  
17679 if (defined $result->{success} ) {
17680 return $result->{success};
17681 }
17682 if (defined $result->{userException}) {
17683 die $result->{userException};
17684 }
17685 if (defined $result->{systemException}) {
17686 die $result->{systemException};
17687 }
17688 if (defined $result->{notFoundException}) {
17689 die $result->{notFoundException};
17690 }
17691 die "setNoteApplicationDataEntry failed: unknown result";
17692 }
17693 sub unsetNoteApplicationDataEntry{
17694 my $self = shift;
17695 my $authenticationToken = shift;
17696 my $guid = shift;
17697 my $key = shift;
17698  
17699 $self->send_unsetNoteApplicationDataEntry($authenticationToken, $guid, $key);
17700 return $self->recv_unsetNoteApplicationDataEntry();
17701 }
17702  
17703 sub send_unsetNoteApplicationDataEntry{
17704 my $self = shift;
17705 my $authenticationToken = shift;
17706 my $guid = shift;
17707 my $key = shift;
17708  
17709 $self->{output}->writeMessageBegin('unsetNoteApplicationDataEntry', TMessageType::CALL, $self->{seqid});
17710 my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->new();
17711 $args->{authenticationToken} = $authenticationToken;
17712 $args->{guid} = $guid;
17713 $args->{key} = $key;
17714 $args->write($self->{output});
17715 $self->{output}->writeMessageEnd();
17716 $self->{output}->getTransport()->flush();
17717 }
17718  
17719 sub recv_unsetNoteApplicationDataEntry{
17720 my $self = shift;
17721  
17722 my $rseqid = 0;
17723 my $fname;
17724 my $mtype = 0;
17725  
17726 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17727 if ($mtype == TMessageType::EXCEPTION) {
17728 my $x = TApplicationException->new();
17729 $x->read($self->{input});
17730 $self->{input}->readMessageEnd();
17731 die $x;
17732 }
17733 my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->new();
17734 $result->read($self->{input});
17735 $self->{input}->readMessageEnd();
17736  
17737 if (defined $result->{success} ) {
17738 return $result->{success};
17739 }
17740 if (defined $result->{userException}) {
17741 die $result->{userException};
17742 }
17743 if (defined $result->{systemException}) {
17744 die $result->{systemException};
17745 }
17746 if (defined $result->{notFoundException}) {
17747 die $result->{notFoundException};
17748 }
17749 die "unsetNoteApplicationDataEntry failed: unknown result";
17750 }
17751 sub getNoteContent{
17752 my $self = shift;
17753 my $authenticationToken = shift;
17754 my $guid = shift;
17755  
17756 $self->send_getNoteContent($authenticationToken, $guid);
17757 return $self->recv_getNoteContent();
17758 }
17759  
17760 sub send_getNoteContent{
17761 my $self = shift;
17762 my $authenticationToken = shift;
17763 my $guid = shift;
17764  
17765 $self->{output}->writeMessageBegin('getNoteContent', TMessageType::CALL, $self->{seqid});
17766 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->new();
17767 $args->{authenticationToken} = $authenticationToken;
17768 $args->{guid} = $guid;
17769 $args->write($self->{output});
17770 $self->{output}->writeMessageEnd();
17771 $self->{output}->getTransport()->flush();
17772 }
17773  
17774 sub recv_getNoteContent{
17775 my $self = shift;
17776  
17777 my $rseqid = 0;
17778 my $fname;
17779 my $mtype = 0;
17780  
17781 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17782 if ($mtype == TMessageType::EXCEPTION) {
17783 my $x = TApplicationException->new();
17784 $x->read($self->{input});
17785 $self->{input}->readMessageEnd();
17786 die $x;
17787 }
17788 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->new();
17789 $result->read($self->{input});
17790 $self->{input}->readMessageEnd();
17791  
17792 if (defined $result->{success} ) {
17793 return $result->{success};
17794 }
17795 if (defined $result->{userException}) {
17796 die $result->{userException};
17797 }
17798 if (defined $result->{systemException}) {
17799 die $result->{systemException};
17800 }
17801 if (defined $result->{notFoundException}) {
17802 die $result->{notFoundException};
17803 }
17804 die "getNoteContent failed: unknown result";
17805 }
17806 sub getNoteSearchText{
17807 my $self = shift;
17808 my $authenticationToken = shift;
17809 my $guid = shift;
17810 my $noteOnly = shift;
17811 my $tokenizeForIndexing = shift;
17812  
17813 $self->send_getNoteSearchText($authenticationToken, $guid, $noteOnly, $tokenizeForIndexing);
17814 return $self->recv_getNoteSearchText();
17815 }
17816  
17817 sub send_getNoteSearchText{
17818 my $self = shift;
17819 my $authenticationToken = shift;
17820 my $guid = shift;
17821 my $noteOnly = shift;
17822 my $tokenizeForIndexing = shift;
17823  
17824 $self->{output}->writeMessageBegin('getNoteSearchText', TMessageType::CALL, $self->{seqid});
17825 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->new();
17826 $args->{authenticationToken} = $authenticationToken;
17827 $args->{guid} = $guid;
17828 $args->{noteOnly} = $noteOnly;
17829 $args->{tokenizeForIndexing} = $tokenizeForIndexing;
17830 $args->write($self->{output});
17831 $self->{output}->writeMessageEnd();
17832 $self->{output}->getTransport()->flush();
17833 }
17834  
17835 sub recv_getNoteSearchText{
17836 my $self = shift;
17837  
17838 my $rseqid = 0;
17839 my $fname;
17840 my $mtype = 0;
17841  
17842 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17843 if ($mtype == TMessageType::EXCEPTION) {
17844 my $x = TApplicationException->new();
17845 $x->read($self->{input});
17846 $self->{input}->readMessageEnd();
17847 die $x;
17848 }
17849 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->new();
17850 $result->read($self->{input});
17851 $self->{input}->readMessageEnd();
17852  
17853 if (defined $result->{success} ) {
17854 return $result->{success};
17855 }
17856 if (defined $result->{userException}) {
17857 die $result->{userException};
17858 }
17859 if (defined $result->{systemException}) {
17860 die $result->{systemException};
17861 }
17862 if (defined $result->{notFoundException}) {
17863 die $result->{notFoundException};
17864 }
17865 die "getNoteSearchText failed: unknown result";
17866 }
17867 sub getResourceSearchText{
17868 my $self = shift;
17869 my $authenticationToken = shift;
17870 my $guid = shift;
17871  
17872 $self->send_getResourceSearchText($authenticationToken, $guid);
17873 return $self->recv_getResourceSearchText();
17874 }
17875  
17876 sub send_getResourceSearchText{
17877 my $self = shift;
17878 my $authenticationToken = shift;
17879 my $guid = shift;
17880  
17881 $self->{output}->writeMessageBegin('getResourceSearchText', TMessageType::CALL, $self->{seqid});
17882 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->new();
17883 $args->{authenticationToken} = $authenticationToken;
17884 $args->{guid} = $guid;
17885 $args->write($self->{output});
17886 $self->{output}->writeMessageEnd();
17887 $self->{output}->getTransport()->flush();
17888 }
17889  
17890 sub recv_getResourceSearchText{
17891 my $self = shift;
17892  
17893 my $rseqid = 0;
17894 my $fname;
17895 my $mtype = 0;
17896  
17897 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17898 if ($mtype == TMessageType::EXCEPTION) {
17899 my $x = TApplicationException->new();
17900 $x->read($self->{input});
17901 $self->{input}->readMessageEnd();
17902 die $x;
17903 }
17904 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->new();
17905 $result->read($self->{input});
17906 $self->{input}->readMessageEnd();
17907  
17908 if (defined $result->{success} ) {
17909 return $result->{success};
17910 }
17911 if (defined $result->{userException}) {
17912 die $result->{userException};
17913 }
17914 if (defined $result->{systemException}) {
17915 die $result->{systemException};
17916 }
17917 if (defined $result->{notFoundException}) {
17918 die $result->{notFoundException};
17919 }
17920 die "getResourceSearchText failed: unknown result";
17921 }
17922 sub getNoteTagNames{
17923 my $self = shift;
17924 my $authenticationToken = shift;
17925 my $guid = shift;
17926  
17927 $self->send_getNoteTagNames($authenticationToken, $guid);
17928 return $self->recv_getNoteTagNames();
17929 }
17930  
17931 sub send_getNoteTagNames{
17932 my $self = shift;
17933 my $authenticationToken = shift;
17934 my $guid = shift;
17935  
17936 $self->{output}->writeMessageBegin('getNoteTagNames', TMessageType::CALL, $self->{seqid});
17937 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->new();
17938 $args->{authenticationToken} = $authenticationToken;
17939 $args->{guid} = $guid;
17940 $args->write($self->{output});
17941 $self->{output}->writeMessageEnd();
17942 $self->{output}->getTransport()->flush();
17943 }
17944  
17945 sub recv_getNoteTagNames{
17946 my $self = shift;
17947  
17948 my $rseqid = 0;
17949 my $fname;
17950 my $mtype = 0;
17951  
17952 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
17953 if ($mtype == TMessageType::EXCEPTION) {
17954 my $x = TApplicationException->new();
17955 $x->read($self->{input});
17956 $self->{input}->readMessageEnd();
17957 die $x;
17958 }
17959 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->new();
17960 $result->read($self->{input});
17961 $self->{input}->readMessageEnd();
17962  
17963 if (defined $result->{success} ) {
17964 return $result->{success};
17965 }
17966 if (defined $result->{userException}) {
17967 die $result->{userException};
17968 }
17969 if (defined $result->{systemException}) {
17970 die $result->{systemException};
17971 }
17972 if (defined $result->{notFoundException}) {
17973 die $result->{notFoundException};
17974 }
17975 die "getNoteTagNames failed: unknown result";
17976 }
17977 sub createNote{
17978 my $self = shift;
17979 my $authenticationToken = shift;
17980 my $note = shift;
17981  
17982 $self->send_createNote($authenticationToken, $note);
17983 return $self->recv_createNote();
17984 }
17985  
17986 sub send_createNote{
17987 my $self = shift;
17988 my $authenticationToken = shift;
17989 my $note = shift;
17990  
17991 $self->{output}->writeMessageBegin('createNote', TMessageType::CALL, $self->{seqid});
17992 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->new();
17993 $args->{authenticationToken} = $authenticationToken;
17994 $args->{note} = $note;
17995 $args->write($self->{output});
17996 $self->{output}->writeMessageEnd();
17997 $self->{output}->getTransport()->flush();
17998 }
17999  
18000 sub recv_createNote{
18001 my $self = shift;
18002  
18003 my $rseqid = 0;
18004 my $fname;
18005 my $mtype = 0;
18006  
18007 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18008 if ($mtype == TMessageType::EXCEPTION) {
18009 my $x = TApplicationException->new();
18010 $x->read($self->{input});
18011 $self->{input}->readMessageEnd();
18012 die $x;
18013 }
18014 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->new();
18015 $result->read($self->{input});
18016 $self->{input}->readMessageEnd();
18017  
18018 if (defined $result->{success} ) {
18019 return $result->{success};
18020 }
18021 if (defined $result->{userException}) {
18022 die $result->{userException};
18023 }
18024 if (defined $result->{systemException}) {
18025 die $result->{systemException};
18026 }
18027 if (defined $result->{notFoundException}) {
18028 die $result->{notFoundException};
18029 }
18030 die "createNote failed: unknown result";
18031 }
18032 sub updateNote{
18033 my $self = shift;
18034 my $authenticationToken = shift;
18035 my $note = shift;
18036  
18037 $self->send_updateNote($authenticationToken, $note);
18038 return $self->recv_updateNote();
18039 }
18040  
18041 sub send_updateNote{
18042 my $self = shift;
18043 my $authenticationToken = shift;
18044 my $note = shift;
18045  
18046 $self->{output}->writeMessageBegin('updateNote', TMessageType::CALL, $self->{seqid});
18047 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->new();
18048 $args->{authenticationToken} = $authenticationToken;
18049 $args->{note} = $note;
18050 $args->write($self->{output});
18051 $self->{output}->writeMessageEnd();
18052 $self->{output}->getTransport()->flush();
18053 }
18054  
18055 sub recv_updateNote{
18056 my $self = shift;
18057  
18058 my $rseqid = 0;
18059 my $fname;
18060 my $mtype = 0;
18061  
18062 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18063 if ($mtype == TMessageType::EXCEPTION) {
18064 my $x = TApplicationException->new();
18065 $x->read($self->{input});
18066 $self->{input}->readMessageEnd();
18067 die $x;
18068 }
18069 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->new();
18070 $result->read($self->{input});
18071 $self->{input}->readMessageEnd();
18072  
18073 if (defined $result->{success} ) {
18074 return $result->{success};
18075 }
18076 if (defined $result->{userException}) {
18077 die $result->{userException};
18078 }
18079 if (defined $result->{systemException}) {
18080 die $result->{systemException};
18081 }
18082 if (defined $result->{notFoundException}) {
18083 die $result->{notFoundException};
18084 }
18085 die "updateNote failed: unknown result";
18086 }
18087 sub deleteNote{
18088 my $self = shift;
18089 my $authenticationToken = shift;
18090 my $guid = shift;
18091  
18092 $self->send_deleteNote($authenticationToken, $guid);
18093 return $self->recv_deleteNote();
18094 }
18095  
18096 sub send_deleteNote{
18097 my $self = shift;
18098 my $authenticationToken = shift;
18099 my $guid = shift;
18100  
18101 $self->{output}->writeMessageBegin('deleteNote', TMessageType::CALL, $self->{seqid});
18102 my $args = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->new();
18103 $args->{authenticationToken} = $authenticationToken;
18104 $args->{guid} = $guid;
18105 $args->write($self->{output});
18106 $self->{output}->writeMessageEnd();
18107 $self->{output}->getTransport()->flush();
18108 }
18109  
18110 sub recv_deleteNote{
18111 my $self = shift;
18112  
18113 my $rseqid = 0;
18114 my $fname;
18115 my $mtype = 0;
18116  
18117 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18118 if ($mtype == TMessageType::EXCEPTION) {
18119 my $x = TApplicationException->new();
18120 $x->read($self->{input});
18121 $self->{input}->readMessageEnd();
18122 die $x;
18123 }
18124 my $result = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->new();
18125 $result->read($self->{input});
18126 $self->{input}->readMessageEnd();
18127  
18128 if (defined $result->{success} ) {
18129 return $result->{success};
18130 }
18131 if (defined $result->{userException}) {
18132 die $result->{userException};
18133 }
18134 if (defined $result->{systemException}) {
18135 die $result->{systemException};
18136 }
18137 if (defined $result->{notFoundException}) {
18138 die $result->{notFoundException};
18139 }
18140 die "deleteNote failed: unknown result";
18141 }
18142 sub expungeNote{
18143 my $self = shift;
18144 my $authenticationToken = shift;
18145 my $guid = shift;
18146  
18147 $self->send_expungeNote($authenticationToken, $guid);
18148 return $self->recv_expungeNote();
18149 }
18150  
18151 sub send_expungeNote{
18152 my $self = shift;
18153 my $authenticationToken = shift;
18154 my $guid = shift;
18155  
18156 $self->{output}->writeMessageBegin('expungeNote', TMessageType::CALL, $self->{seqid});
18157 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->new();
18158 $args->{authenticationToken} = $authenticationToken;
18159 $args->{guid} = $guid;
18160 $args->write($self->{output});
18161 $self->{output}->writeMessageEnd();
18162 $self->{output}->getTransport()->flush();
18163 }
18164  
18165 sub recv_expungeNote{
18166 my $self = shift;
18167  
18168 my $rseqid = 0;
18169 my $fname;
18170 my $mtype = 0;
18171  
18172 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18173 if ($mtype == TMessageType::EXCEPTION) {
18174 my $x = TApplicationException->new();
18175 $x->read($self->{input});
18176 $self->{input}->readMessageEnd();
18177 die $x;
18178 }
18179 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->new();
18180 $result->read($self->{input});
18181 $self->{input}->readMessageEnd();
18182  
18183 if (defined $result->{success} ) {
18184 return $result->{success};
18185 }
18186 if (defined $result->{userException}) {
18187 die $result->{userException};
18188 }
18189 if (defined $result->{systemException}) {
18190 die $result->{systemException};
18191 }
18192 if (defined $result->{notFoundException}) {
18193 die $result->{notFoundException};
18194 }
18195 die "expungeNote failed: unknown result";
18196 }
18197 sub expungeNotes{
18198 my $self = shift;
18199 my $authenticationToken = shift;
18200 my $noteGuids = shift;
18201  
18202 $self->send_expungeNotes($authenticationToken, $noteGuids);
18203 return $self->recv_expungeNotes();
18204 }
18205  
18206 sub send_expungeNotes{
18207 my $self = shift;
18208 my $authenticationToken = shift;
18209 my $noteGuids = shift;
18210  
18211 $self->{output}->writeMessageBegin('expungeNotes', TMessageType::CALL, $self->{seqid});
18212 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->new();
18213 $args->{authenticationToken} = $authenticationToken;
18214 $args->{noteGuids} = $noteGuids;
18215 $args->write($self->{output});
18216 $self->{output}->writeMessageEnd();
18217 $self->{output}->getTransport()->flush();
18218 }
18219  
18220 sub recv_expungeNotes{
18221 my $self = shift;
18222  
18223 my $rseqid = 0;
18224 my $fname;
18225 my $mtype = 0;
18226  
18227 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18228 if ($mtype == TMessageType::EXCEPTION) {
18229 my $x = TApplicationException->new();
18230 $x->read($self->{input});
18231 $self->{input}->readMessageEnd();
18232 die $x;
18233 }
18234 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->new();
18235 $result->read($self->{input});
18236 $self->{input}->readMessageEnd();
18237  
18238 if (defined $result->{success} ) {
18239 return $result->{success};
18240 }
18241 if (defined $result->{userException}) {
18242 die $result->{userException};
18243 }
18244 if (defined $result->{systemException}) {
18245 die $result->{systemException};
18246 }
18247 if (defined $result->{notFoundException}) {
18248 die $result->{notFoundException};
18249 }
18250 die "expungeNotes failed: unknown result";
18251 }
18252 sub expungeInactiveNotes{
18253 my $self = shift;
18254 my $authenticationToken = shift;
18255  
18256 $self->send_expungeInactiveNotes($authenticationToken);
18257 return $self->recv_expungeInactiveNotes();
18258 }
18259  
18260 sub send_expungeInactiveNotes{
18261 my $self = shift;
18262 my $authenticationToken = shift;
18263  
18264 $self->{output}->writeMessageBegin('expungeInactiveNotes', TMessageType::CALL, $self->{seqid});
18265 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->new();
18266 $args->{authenticationToken} = $authenticationToken;
18267 $args->write($self->{output});
18268 $self->{output}->writeMessageEnd();
18269 $self->{output}->getTransport()->flush();
18270 }
18271  
18272 sub recv_expungeInactiveNotes{
18273 my $self = shift;
18274  
18275 my $rseqid = 0;
18276 my $fname;
18277 my $mtype = 0;
18278  
18279 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18280 if ($mtype == TMessageType::EXCEPTION) {
18281 my $x = TApplicationException->new();
18282 $x->read($self->{input});
18283 $self->{input}->readMessageEnd();
18284 die $x;
18285 }
18286 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->new();
18287 $result->read($self->{input});
18288 $self->{input}->readMessageEnd();
18289  
18290 if (defined $result->{success} ) {
18291 return $result->{success};
18292 }
18293 if (defined $result->{userException}) {
18294 die $result->{userException};
18295 }
18296 if (defined $result->{systemException}) {
18297 die $result->{systemException};
18298 }
18299 die "expungeInactiveNotes failed: unknown result";
18300 }
18301 sub copyNote{
18302 my $self = shift;
18303 my $authenticationToken = shift;
18304 my $noteGuid = shift;
18305 my $toNotebookGuid = shift;
18306  
18307 $self->send_copyNote($authenticationToken, $noteGuid, $toNotebookGuid);
18308 return $self->recv_copyNote();
18309 }
18310  
18311 sub send_copyNote{
18312 my $self = shift;
18313 my $authenticationToken = shift;
18314 my $noteGuid = shift;
18315 my $toNotebookGuid = shift;
18316  
18317 $self->{output}->writeMessageBegin('copyNote', TMessageType::CALL, $self->{seqid});
18318 my $args = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->new();
18319 $args->{authenticationToken} = $authenticationToken;
18320 $args->{noteGuid} = $noteGuid;
18321 $args->{toNotebookGuid} = $toNotebookGuid;
18322 $args->write($self->{output});
18323 $self->{output}->writeMessageEnd();
18324 $self->{output}->getTransport()->flush();
18325 }
18326  
18327 sub recv_copyNote{
18328 my $self = shift;
18329  
18330 my $rseqid = 0;
18331 my $fname;
18332 my $mtype = 0;
18333  
18334 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18335 if ($mtype == TMessageType::EXCEPTION) {
18336 my $x = TApplicationException->new();
18337 $x->read($self->{input});
18338 $self->{input}->readMessageEnd();
18339 die $x;
18340 }
18341 my $result = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->new();
18342 $result->read($self->{input});
18343 $self->{input}->readMessageEnd();
18344  
18345 if (defined $result->{success} ) {
18346 return $result->{success};
18347 }
18348 if (defined $result->{userException}) {
18349 die $result->{userException};
18350 }
18351 if (defined $result->{systemException}) {
18352 die $result->{systemException};
18353 }
18354 if (defined $result->{notFoundException}) {
18355 die $result->{notFoundException};
18356 }
18357 die "copyNote failed: unknown result";
18358 }
18359 sub listNoteVersions{
18360 my $self = shift;
18361 my $authenticationToken = shift;
18362 my $noteGuid = shift;
18363  
18364 $self->send_listNoteVersions($authenticationToken, $noteGuid);
18365 return $self->recv_listNoteVersions();
18366 }
18367  
18368 sub send_listNoteVersions{
18369 my $self = shift;
18370 my $authenticationToken = shift;
18371 my $noteGuid = shift;
18372  
18373 $self->{output}->writeMessageBegin('listNoteVersions', TMessageType::CALL, $self->{seqid});
18374 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->new();
18375 $args->{authenticationToken} = $authenticationToken;
18376 $args->{noteGuid} = $noteGuid;
18377 $args->write($self->{output});
18378 $self->{output}->writeMessageEnd();
18379 $self->{output}->getTransport()->flush();
18380 }
18381  
18382 sub recv_listNoteVersions{
18383 my $self = shift;
18384  
18385 my $rseqid = 0;
18386 my $fname;
18387 my $mtype = 0;
18388  
18389 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18390 if ($mtype == TMessageType::EXCEPTION) {
18391 my $x = TApplicationException->new();
18392 $x->read($self->{input});
18393 $self->{input}->readMessageEnd();
18394 die $x;
18395 }
18396 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->new();
18397 $result->read($self->{input});
18398 $self->{input}->readMessageEnd();
18399  
18400 if (defined $result->{success} ) {
18401 return $result->{success};
18402 }
18403 if (defined $result->{userException}) {
18404 die $result->{userException};
18405 }
18406 if (defined $result->{systemException}) {
18407 die $result->{systemException};
18408 }
18409 if (defined $result->{notFoundException}) {
18410 die $result->{notFoundException};
18411 }
18412 die "listNoteVersions failed: unknown result";
18413 }
18414 sub getNoteVersion{
18415 my $self = shift;
18416 my $authenticationToken = shift;
18417 my $noteGuid = shift;
18418 my $updateSequenceNum = shift;
18419 my $withResourcesData = shift;
18420 my $withResourcesRecognition = shift;
18421 my $withResourcesAlternateData = shift;
18422  
18423 $self->send_getNoteVersion($authenticationToken, $noteGuid, $updateSequenceNum, $withResourcesData, $withResourcesRecognition, $withResourcesAlternateData);
18424 return $self->recv_getNoteVersion();
18425 }
18426  
18427 sub send_getNoteVersion{
18428 my $self = shift;
18429 my $authenticationToken = shift;
18430 my $noteGuid = shift;
18431 my $updateSequenceNum = shift;
18432 my $withResourcesData = shift;
18433 my $withResourcesRecognition = shift;
18434 my $withResourcesAlternateData = shift;
18435  
18436 $self->{output}->writeMessageBegin('getNoteVersion', TMessageType::CALL, $self->{seqid});
18437 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->new();
18438 $args->{authenticationToken} = $authenticationToken;
18439 $args->{noteGuid} = $noteGuid;
18440 $args->{updateSequenceNum} = $updateSequenceNum;
18441 $args->{withResourcesData} = $withResourcesData;
18442 $args->{withResourcesRecognition} = $withResourcesRecognition;
18443 $args->{withResourcesAlternateData} = $withResourcesAlternateData;
18444 $args->write($self->{output});
18445 $self->{output}->writeMessageEnd();
18446 $self->{output}->getTransport()->flush();
18447 }
18448  
18449 sub recv_getNoteVersion{
18450 my $self = shift;
18451  
18452 my $rseqid = 0;
18453 my $fname;
18454 my $mtype = 0;
18455  
18456 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18457 if ($mtype == TMessageType::EXCEPTION) {
18458 my $x = TApplicationException->new();
18459 $x->read($self->{input});
18460 $self->{input}->readMessageEnd();
18461 die $x;
18462 }
18463 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->new();
18464 $result->read($self->{input});
18465 $self->{input}->readMessageEnd();
18466  
18467 if (defined $result->{success} ) {
18468 return $result->{success};
18469 }
18470 if (defined $result->{userException}) {
18471 die $result->{userException};
18472 }
18473 if (defined $result->{systemException}) {
18474 die $result->{systemException};
18475 }
18476 if (defined $result->{notFoundException}) {
18477 die $result->{notFoundException};
18478 }
18479 die "getNoteVersion failed: unknown result";
18480 }
18481 sub getResource{
18482 my $self = shift;
18483 my $authenticationToken = shift;
18484 my $guid = shift;
18485 my $withData = shift;
18486 my $withRecognition = shift;
18487 my $withAttributes = shift;
18488 my $withAlternateData = shift;
18489  
18490 $self->send_getResource($authenticationToken, $guid, $withData, $withRecognition, $withAttributes, $withAlternateData);
18491 return $self->recv_getResource();
18492 }
18493  
18494 sub send_getResource{
18495 my $self = shift;
18496 my $authenticationToken = shift;
18497 my $guid = shift;
18498 my $withData = shift;
18499 my $withRecognition = shift;
18500 my $withAttributes = shift;
18501 my $withAlternateData = shift;
18502  
18503 $self->{output}->writeMessageBegin('getResource', TMessageType::CALL, $self->{seqid});
18504 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->new();
18505 $args->{authenticationToken} = $authenticationToken;
18506 $args->{guid} = $guid;
18507 $args->{withData} = $withData;
18508 $args->{withRecognition} = $withRecognition;
18509 $args->{withAttributes} = $withAttributes;
18510 $args->{withAlternateData} = $withAlternateData;
18511 $args->write($self->{output});
18512 $self->{output}->writeMessageEnd();
18513 $self->{output}->getTransport()->flush();
18514 }
18515  
18516 sub recv_getResource{
18517 my $self = shift;
18518  
18519 my $rseqid = 0;
18520 my $fname;
18521 my $mtype = 0;
18522  
18523 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18524 if ($mtype == TMessageType::EXCEPTION) {
18525 my $x = TApplicationException->new();
18526 $x->read($self->{input});
18527 $self->{input}->readMessageEnd();
18528 die $x;
18529 }
18530 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->new();
18531 $result->read($self->{input});
18532 $self->{input}->readMessageEnd();
18533  
18534 if (defined $result->{success} ) {
18535 return $result->{success};
18536 }
18537 if (defined $result->{userException}) {
18538 die $result->{userException};
18539 }
18540 if (defined $result->{systemException}) {
18541 die $result->{systemException};
18542 }
18543 if (defined $result->{notFoundException}) {
18544 die $result->{notFoundException};
18545 }
18546 die "getResource failed: unknown result";
18547 }
18548 sub getResourceApplicationData{
18549 my $self = shift;
18550 my $authenticationToken = shift;
18551 my $guid = shift;
18552  
18553 $self->send_getResourceApplicationData($authenticationToken, $guid);
18554 return $self->recv_getResourceApplicationData();
18555 }
18556  
18557 sub send_getResourceApplicationData{
18558 my $self = shift;
18559 my $authenticationToken = shift;
18560 my $guid = shift;
18561  
18562 $self->{output}->writeMessageBegin('getResourceApplicationData', TMessageType::CALL, $self->{seqid});
18563 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->new();
18564 $args->{authenticationToken} = $authenticationToken;
18565 $args->{guid} = $guid;
18566 $args->write($self->{output});
18567 $self->{output}->writeMessageEnd();
18568 $self->{output}->getTransport()->flush();
18569 }
18570  
18571 sub recv_getResourceApplicationData{
18572 my $self = shift;
18573  
18574 my $rseqid = 0;
18575 my $fname;
18576 my $mtype = 0;
18577  
18578 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18579 if ($mtype == TMessageType::EXCEPTION) {
18580 my $x = TApplicationException->new();
18581 $x->read($self->{input});
18582 $self->{input}->readMessageEnd();
18583 die $x;
18584 }
18585 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->new();
18586 $result->read($self->{input});
18587 $self->{input}->readMessageEnd();
18588  
18589 if (defined $result->{success} ) {
18590 return $result->{success};
18591 }
18592 if (defined $result->{userException}) {
18593 die $result->{userException};
18594 }
18595 if (defined $result->{systemException}) {
18596 die $result->{systemException};
18597 }
18598 if (defined $result->{notFoundException}) {
18599 die $result->{notFoundException};
18600 }
18601 die "getResourceApplicationData failed: unknown result";
18602 }
18603 sub getResourceApplicationDataEntry{
18604 my $self = shift;
18605 my $authenticationToken = shift;
18606 my $guid = shift;
18607 my $key = shift;
18608  
18609 $self->send_getResourceApplicationDataEntry($authenticationToken, $guid, $key);
18610 return $self->recv_getResourceApplicationDataEntry();
18611 }
18612  
18613 sub send_getResourceApplicationDataEntry{
18614 my $self = shift;
18615 my $authenticationToken = shift;
18616 my $guid = shift;
18617 my $key = shift;
18618  
18619 $self->{output}->writeMessageBegin('getResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
18620 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->new();
18621 $args->{authenticationToken} = $authenticationToken;
18622 $args->{guid} = $guid;
18623 $args->{key} = $key;
18624 $args->write($self->{output});
18625 $self->{output}->writeMessageEnd();
18626 $self->{output}->getTransport()->flush();
18627 }
18628  
18629 sub recv_getResourceApplicationDataEntry{
18630 my $self = shift;
18631  
18632 my $rseqid = 0;
18633 my $fname;
18634 my $mtype = 0;
18635  
18636 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18637 if ($mtype == TMessageType::EXCEPTION) {
18638 my $x = TApplicationException->new();
18639 $x->read($self->{input});
18640 $self->{input}->readMessageEnd();
18641 die $x;
18642 }
18643 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->new();
18644 $result->read($self->{input});
18645 $self->{input}->readMessageEnd();
18646  
18647 if (defined $result->{success} ) {
18648 return $result->{success};
18649 }
18650 if (defined $result->{userException}) {
18651 die $result->{userException};
18652 }
18653 if (defined $result->{systemException}) {
18654 die $result->{systemException};
18655 }
18656 if (defined $result->{notFoundException}) {
18657 die $result->{notFoundException};
18658 }
18659 die "getResourceApplicationDataEntry failed: unknown result";
18660 }
18661 sub setResourceApplicationDataEntry{
18662 my $self = shift;
18663 my $authenticationToken = shift;
18664 my $guid = shift;
18665 my $key = shift;
18666 my $value = shift;
18667  
18668 $self->send_setResourceApplicationDataEntry($authenticationToken, $guid, $key, $value);
18669 return $self->recv_setResourceApplicationDataEntry();
18670 }
18671  
18672 sub send_setResourceApplicationDataEntry{
18673 my $self = shift;
18674 my $authenticationToken = shift;
18675 my $guid = shift;
18676 my $key = shift;
18677 my $value = shift;
18678  
18679 $self->{output}->writeMessageBegin('setResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
18680 my $args = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->new();
18681 $args->{authenticationToken} = $authenticationToken;
18682 $args->{guid} = $guid;
18683 $args->{key} = $key;
18684 $args->{value} = $value;
18685 $args->write($self->{output});
18686 $self->{output}->writeMessageEnd();
18687 $self->{output}->getTransport()->flush();
18688 }
18689  
18690 sub recv_setResourceApplicationDataEntry{
18691 my $self = shift;
18692  
18693 my $rseqid = 0;
18694 my $fname;
18695 my $mtype = 0;
18696  
18697 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18698 if ($mtype == TMessageType::EXCEPTION) {
18699 my $x = TApplicationException->new();
18700 $x->read($self->{input});
18701 $self->{input}->readMessageEnd();
18702 die $x;
18703 }
18704 my $result = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->new();
18705 $result->read($self->{input});
18706 $self->{input}->readMessageEnd();
18707  
18708 if (defined $result->{success} ) {
18709 return $result->{success};
18710 }
18711 if (defined $result->{userException}) {
18712 die $result->{userException};
18713 }
18714 if (defined $result->{systemException}) {
18715 die $result->{systemException};
18716 }
18717 if (defined $result->{notFoundException}) {
18718 die $result->{notFoundException};
18719 }
18720 die "setResourceApplicationDataEntry failed: unknown result";
18721 }
18722 sub unsetResourceApplicationDataEntry{
18723 my $self = shift;
18724 my $authenticationToken = shift;
18725 my $guid = shift;
18726 my $key = shift;
18727  
18728 $self->send_unsetResourceApplicationDataEntry($authenticationToken, $guid, $key);
18729 return $self->recv_unsetResourceApplicationDataEntry();
18730 }
18731  
18732 sub send_unsetResourceApplicationDataEntry{
18733 my $self = shift;
18734 my $authenticationToken = shift;
18735 my $guid = shift;
18736 my $key = shift;
18737  
18738 $self->{output}->writeMessageBegin('unsetResourceApplicationDataEntry', TMessageType::CALL, $self->{seqid});
18739 my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->new();
18740 $args->{authenticationToken} = $authenticationToken;
18741 $args->{guid} = $guid;
18742 $args->{key} = $key;
18743 $args->write($self->{output});
18744 $self->{output}->writeMessageEnd();
18745 $self->{output}->getTransport()->flush();
18746 }
18747  
18748 sub recv_unsetResourceApplicationDataEntry{
18749 my $self = shift;
18750  
18751 my $rseqid = 0;
18752 my $fname;
18753 my $mtype = 0;
18754  
18755 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18756 if ($mtype == TMessageType::EXCEPTION) {
18757 my $x = TApplicationException->new();
18758 $x->read($self->{input});
18759 $self->{input}->readMessageEnd();
18760 die $x;
18761 }
18762 my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->new();
18763 $result->read($self->{input});
18764 $self->{input}->readMessageEnd();
18765  
18766 if (defined $result->{success} ) {
18767 return $result->{success};
18768 }
18769 if (defined $result->{userException}) {
18770 die $result->{userException};
18771 }
18772 if (defined $result->{systemException}) {
18773 die $result->{systemException};
18774 }
18775 if (defined $result->{notFoundException}) {
18776 die $result->{notFoundException};
18777 }
18778 die "unsetResourceApplicationDataEntry failed: unknown result";
18779 }
18780 sub updateResource{
18781 my $self = shift;
18782 my $authenticationToken = shift;
18783 my $resource = shift;
18784  
18785 $self->send_updateResource($authenticationToken, $resource);
18786 return $self->recv_updateResource();
18787 }
18788  
18789 sub send_updateResource{
18790 my $self = shift;
18791 my $authenticationToken = shift;
18792 my $resource = shift;
18793  
18794 $self->{output}->writeMessageBegin('updateResource', TMessageType::CALL, $self->{seqid});
18795 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->new();
18796 $args->{authenticationToken} = $authenticationToken;
18797 $args->{resource} = $resource;
18798 $args->write($self->{output});
18799 $self->{output}->writeMessageEnd();
18800 $self->{output}->getTransport()->flush();
18801 }
18802  
18803 sub recv_updateResource{
18804 my $self = shift;
18805  
18806 my $rseqid = 0;
18807 my $fname;
18808 my $mtype = 0;
18809  
18810 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18811 if ($mtype == TMessageType::EXCEPTION) {
18812 my $x = TApplicationException->new();
18813 $x->read($self->{input});
18814 $self->{input}->readMessageEnd();
18815 die $x;
18816 }
18817 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->new();
18818 $result->read($self->{input});
18819 $self->{input}->readMessageEnd();
18820  
18821 if (defined $result->{success} ) {
18822 return $result->{success};
18823 }
18824 if (defined $result->{userException}) {
18825 die $result->{userException};
18826 }
18827 if (defined $result->{systemException}) {
18828 die $result->{systemException};
18829 }
18830 if (defined $result->{notFoundException}) {
18831 die $result->{notFoundException};
18832 }
18833 die "updateResource failed: unknown result";
18834 }
18835 sub getResourceData{
18836 my $self = shift;
18837 my $authenticationToken = shift;
18838 my $guid = shift;
18839  
18840 $self->send_getResourceData($authenticationToken, $guid);
18841 return $self->recv_getResourceData();
18842 }
18843  
18844 sub send_getResourceData{
18845 my $self = shift;
18846 my $authenticationToken = shift;
18847 my $guid = shift;
18848  
18849 $self->{output}->writeMessageBegin('getResourceData', TMessageType::CALL, $self->{seqid});
18850 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->new();
18851 $args->{authenticationToken} = $authenticationToken;
18852 $args->{guid} = $guid;
18853 $args->write($self->{output});
18854 $self->{output}->writeMessageEnd();
18855 $self->{output}->getTransport()->flush();
18856 }
18857  
18858 sub recv_getResourceData{
18859 my $self = shift;
18860  
18861 my $rseqid = 0;
18862 my $fname;
18863 my $mtype = 0;
18864  
18865 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18866 if ($mtype == TMessageType::EXCEPTION) {
18867 my $x = TApplicationException->new();
18868 $x->read($self->{input});
18869 $self->{input}->readMessageEnd();
18870 die $x;
18871 }
18872 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->new();
18873 $result->read($self->{input});
18874 $self->{input}->readMessageEnd();
18875  
18876 if (defined $result->{success} ) {
18877 return $result->{success};
18878 }
18879 if (defined $result->{userException}) {
18880 die $result->{userException};
18881 }
18882 if (defined $result->{systemException}) {
18883 die $result->{systemException};
18884 }
18885 if (defined $result->{notFoundException}) {
18886 die $result->{notFoundException};
18887 }
18888 die "getResourceData failed: unknown result";
18889 }
18890 sub getResourceByHash{
18891 my $self = shift;
18892 my $authenticationToken = shift;
18893 my $noteGuid = shift;
18894 my $contentHash = shift;
18895 my $withData = shift;
18896 my $withRecognition = shift;
18897 my $withAlternateData = shift;
18898  
18899 $self->send_getResourceByHash($authenticationToken, $noteGuid, $contentHash, $withData, $withRecognition, $withAlternateData);
18900 return $self->recv_getResourceByHash();
18901 }
18902  
18903 sub send_getResourceByHash{
18904 my $self = shift;
18905 my $authenticationToken = shift;
18906 my $noteGuid = shift;
18907 my $contentHash = shift;
18908 my $withData = shift;
18909 my $withRecognition = shift;
18910 my $withAlternateData = shift;
18911  
18912 $self->{output}->writeMessageBegin('getResourceByHash', TMessageType::CALL, $self->{seqid});
18913 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->new();
18914 $args->{authenticationToken} = $authenticationToken;
18915 $args->{noteGuid} = $noteGuid;
18916 $args->{contentHash} = $contentHash;
18917 $args->{withData} = $withData;
18918 $args->{withRecognition} = $withRecognition;
18919 $args->{withAlternateData} = $withAlternateData;
18920 $args->write($self->{output});
18921 $self->{output}->writeMessageEnd();
18922 $self->{output}->getTransport()->flush();
18923 }
18924  
18925 sub recv_getResourceByHash{
18926 my $self = shift;
18927  
18928 my $rseqid = 0;
18929 my $fname;
18930 my $mtype = 0;
18931  
18932 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18933 if ($mtype == TMessageType::EXCEPTION) {
18934 my $x = TApplicationException->new();
18935 $x->read($self->{input});
18936 $self->{input}->readMessageEnd();
18937 die $x;
18938 }
18939 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->new();
18940 $result->read($self->{input});
18941 $self->{input}->readMessageEnd();
18942  
18943 if (defined $result->{success} ) {
18944 return $result->{success};
18945 }
18946 if (defined $result->{userException}) {
18947 die $result->{userException};
18948 }
18949 if (defined $result->{systemException}) {
18950 die $result->{systemException};
18951 }
18952 if (defined $result->{notFoundException}) {
18953 die $result->{notFoundException};
18954 }
18955 die "getResourceByHash failed: unknown result";
18956 }
18957 sub getResourceRecognition{
18958 my $self = shift;
18959 my $authenticationToken = shift;
18960 my $guid = shift;
18961  
18962 $self->send_getResourceRecognition($authenticationToken, $guid);
18963 return $self->recv_getResourceRecognition();
18964 }
18965  
18966 sub send_getResourceRecognition{
18967 my $self = shift;
18968 my $authenticationToken = shift;
18969 my $guid = shift;
18970  
18971 $self->{output}->writeMessageBegin('getResourceRecognition', TMessageType::CALL, $self->{seqid});
18972 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->new();
18973 $args->{authenticationToken} = $authenticationToken;
18974 $args->{guid} = $guid;
18975 $args->write($self->{output});
18976 $self->{output}->writeMessageEnd();
18977 $self->{output}->getTransport()->flush();
18978 }
18979  
18980 sub recv_getResourceRecognition{
18981 my $self = shift;
18982  
18983 my $rseqid = 0;
18984 my $fname;
18985 my $mtype = 0;
18986  
18987 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
18988 if ($mtype == TMessageType::EXCEPTION) {
18989 my $x = TApplicationException->new();
18990 $x->read($self->{input});
18991 $self->{input}->readMessageEnd();
18992 die $x;
18993 }
18994 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->new();
18995 $result->read($self->{input});
18996 $self->{input}->readMessageEnd();
18997  
18998 if (defined $result->{success} ) {
18999 return $result->{success};
19000 }
19001 if (defined $result->{userException}) {
19002 die $result->{userException};
19003 }
19004 if (defined $result->{systemException}) {
19005 die $result->{systemException};
19006 }
19007 if (defined $result->{notFoundException}) {
19008 die $result->{notFoundException};
19009 }
19010 die "getResourceRecognition failed: unknown result";
19011 }
19012 sub getResourceAlternateData{
19013 my $self = shift;
19014 my $authenticationToken = shift;
19015 my $guid = shift;
19016  
19017 $self->send_getResourceAlternateData($authenticationToken, $guid);
19018 return $self->recv_getResourceAlternateData();
19019 }
19020  
19021 sub send_getResourceAlternateData{
19022 my $self = shift;
19023 my $authenticationToken = shift;
19024 my $guid = shift;
19025  
19026 $self->{output}->writeMessageBegin('getResourceAlternateData', TMessageType::CALL, $self->{seqid});
19027 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->new();
19028 $args->{authenticationToken} = $authenticationToken;
19029 $args->{guid} = $guid;
19030 $args->write($self->{output});
19031 $self->{output}->writeMessageEnd();
19032 $self->{output}->getTransport()->flush();
19033 }
19034  
19035 sub recv_getResourceAlternateData{
19036 my $self = shift;
19037  
19038 my $rseqid = 0;
19039 my $fname;
19040 my $mtype = 0;
19041  
19042 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19043 if ($mtype == TMessageType::EXCEPTION) {
19044 my $x = TApplicationException->new();
19045 $x->read($self->{input});
19046 $self->{input}->readMessageEnd();
19047 die $x;
19048 }
19049 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->new();
19050 $result->read($self->{input});
19051 $self->{input}->readMessageEnd();
19052  
19053 if (defined $result->{success} ) {
19054 return $result->{success};
19055 }
19056 if (defined $result->{userException}) {
19057 die $result->{userException};
19058 }
19059 if (defined $result->{systemException}) {
19060 die $result->{systemException};
19061 }
19062 if (defined $result->{notFoundException}) {
19063 die $result->{notFoundException};
19064 }
19065 die "getResourceAlternateData failed: unknown result";
19066 }
19067 sub getResourceAttributes{
19068 my $self = shift;
19069 my $authenticationToken = shift;
19070 my $guid = shift;
19071  
19072 $self->send_getResourceAttributes($authenticationToken, $guid);
19073 return $self->recv_getResourceAttributes();
19074 }
19075  
19076 sub send_getResourceAttributes{
19077 my $self = shift;
19078 my $authenticationToken = shift;
19079 my $guid = shift;
19080  
19081 $self->{output}->writeMessageBegin('getResourceAttributes', TMessageType::CALL, $self->{seqid});
19082 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->new();
19083 $args->{authenticationToken} = $authenticationToken;
19084 $args->{guid} = $guid;
19085 $args->write($self->{output});
19086 $self->{output}->writeMessageEnd();
19087 $self->{output}->getTransport()->flush();
19088 }
19089  
19090 sub recv_getResourceAttributes{
19091 my $self = shift;
19092  
19093 my $rseqid = 0;
19094 my $fname;
19095 my $mtype = 0;
19096  
19097 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19098 if ($mtype == TMessageType::EXCEPTION) {
19099 my $x = TApplicationException->new();
19100 $x->read($self->{input});
19101 $self->{input}->readMessageEnd();
19102 die $x;
19103 }
19104 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->new();
19105 $result->read($self->{input});
19106 $self->{input}->readMessageEnd();
19107  
19108 if (defined $result->{success} ) {
19109 return $result->{success};
19110 }
19111 if (defined $result->{userException}) {
19112 die $result->{userException};
19113 }
19114 if (defined $result->{systemException}) {
19115 die $result->{systemException};
19116 }
19117 if (defined $result->{notFoundException}) {
19118 die $result->{notFoundException};
19119 }
19120 die "getResourceAttributes failed: unknown result";
19121 }
19122 sub getAccountSize{
19123 my $self = shift;
19124 my $authenticationToken = shift;
19125  
19126 $self->send_getAccountSize($authenticationToken);
19127 return $self->recv_getAccountSize();
19128 }
19129  
19130 sub send_getAccountSize{
19131 my $self = shift;
19132 my $authenticationToken = shift;
19133  
19134 $self->{output}->writeMessageBegin('getAccountSize', TMessageType::CALL, $self->{seqid});
19135 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->new();
19136 $args->{authenticationToken} = $authenticationToken;
19137 $args->write($self->{output});
19138 $self->{output}->writeMessageEnd();
19139 $self->{output}->getTransport()->flush();
19140 }
19141  
19142 sub recv_getAccountSize{
19143 my $self = shift;
19144  
19145 my $rseqid = 0;
19146 my $fname;
19147 my $mtype = 0;
19148  
19149 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19150 if ($mtype == TMessageType::EXCEPTION) {
19151 my $x = TApplicationException->new();
19152 $x->read($self->{input});
19153 $self->{input}->readMessageEnd();
19154 die $x;
19155 }
19156 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->new();
19157 $result->read($self->{input});
19158 $self->{input}->readMessageEnd();
19159  
19160 if (defined $result->{success} ) {
19161 return $result->{success};
19162 }
19163 if (defined $result->{userException}) {
19164 die $result->{userException};
19165 }
19166 if (defined $result->{systemException}) {
19167 die $result->{systemException};
19168 }
19169 die "getAccountSize failed: unknown result";
19170 }
19171 sub getAds{
19172 my $self = shift;
19173 my $authenticationToken = shift;
19174 my $adParameters = shift;
19175  
19176 $self->send_getAds($authenticationToken, $adParameters);
19177 return $self->recv_getAds();
19178 }
19179  
19180 sub send_getAds{
19181 my $self = shift;
19182 my $authenticationToken = shift;
19183 my $adParameters = shift;
19184  
19185 $self->{output}->writeMessageBegin('getAds', TMessageType::CALL, $self->{seqid});
19186 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->new();
19187 $args->{authenticationToken} = $authenticationToken;
19188 $args->{adParameters} = $adParameters;
19189 $args->write($self->{output});
19190 $self->{output}->writeMessageEnd();
19191 $self->{output}->getTransport()->flush();
19192 }
19193  
19194 sub recv_getAds{
19195 my $self = shift;
19196  
19197 my $rseqid = 0;
19198 my $fname;
19199 my $mtype = 0;
19200  
19201 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19202 if ($mtype == TMessageType::EXCEPTION) {
19203 my $x = TApplicationException->new();
19204 $x->read($self->{input});
19205 $self->{input}->readMessageEnd();
19206 die $x;
19207 }
19208 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->new();
19209 $result->read($self->{input});
19210 $self->{input}->readMessageEnd();
19211  
19212 if (defined $result->{success} ) {
19213 return $result->{success};
19214 }
19215 if (defined $result->{userException}) {
19216 die $result->{userException};
19217 }
19218 if (defined $result->{systemException}) {
19219 die $result->{systemException};
19220 }
19221 die "getAds failed: unknown result";
19222 }
19223 sub getRandomAd{
19224 my $self = shift;
19225 my $authenticationToken = shift;
19226 my $adParameters = shift;
19227  
19228 $self->send_getRandomAd($authenticationToken, $adParameters);
19229 return $self->recv_getRandomAd();
19230 }
19231  
19232 sub send_getRandomAd{
19233 my $self = shift;
19234 my $authenticationToken = shift;
19235 my $adParameters = shift;
19236  
19237 $self->{output}->writeMessageBegin('getRandomAd', TMessageType::CALL, $self->{seqid});
19238 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->new();
19239 $args->{authenticationToken} = $authenticationToken;
19240 $args->{adParameters} = $adParameters;
19241 $args->write($self->{output});
19242 $self->{output}->writeMessageEnd();
19243 $self->{output}->getTransport()->flush();
19244 }
19245  
19246 sub recv_getRandomAd{
19247 my $self = shift;
19248  
19249 my $rseqid = 0;
19250 my $fname;
19251 my $mtype = 0;
19252  
19253 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19254 if ($mtype == TMessageType::EXCEPTION) {
19255 my $x = TApplicationException->new();
19256 $x->read($self->{input});
19257 $self->{input}->readMessageEnd();
19258 die $x;
19259 }
19260 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->new();
19261 $result->read($self->{input});
19262 $self->{input}->readMessageEnd();
19263  
19264 if (defined $result->{success} ) {
19265 return $result->{success};
19266 }
19267 if (defined $result->{userException}) {
19268 die $result->{userException};
19269 }
19270 if (defined $result->{systemException}) {
19271 die $result->{systemException};
19272 }
19273 die "getRandomAd failed: unknown result";
19274 }
19275 sub getPublicNotebook{
19276 my $self = shift;
19277 my $userId = shift;
19278 my $publicUri = shift;
19279  
19280 $self->send_getPublicNotebook($userId, $publicUri);
19281 return $self->recv_getPublicNotebook();
19282 }
19283  
19284 sub send_getPublicNotebook{
19285 my $self = shift;
19286 my $userId = shift;
19287 my $publicUri = shift;
19288  
19289 $self->{output}->writeMessageBegin('getPublicNotebook', TMessageType::CALL, $self->{seqid});
19290 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->new();
19291 $args->{userId} = $userId;
19292 $args->{publicUri} = $publicUri;
19293 $args->write($self->{output});
19294 $self->{output}->writeMessageEnd();
19295 $self->{output}->getTransport()->flush();
19296 }
19297  
19298 sub recv_getPublicNotebook{
19299 my $self = shift;
19300  
19301 my $rseqid = 0;
19302 my $fname;
19303 my $mtype = 0;
19304  
19305 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19306 if ($mtype == TMessageType::EXCEPTION) {
19307 my $x = TApplicationException->new();
19308 $x->read($self->{input});
19309 $self->{input}->readMessageEnd();
19310 die $x;
19311 }
19312 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->new();
19313 $result->read($self->{input});
19314 $self->{input}->readMessageEnd();
19315  
19316 if (defined $result->{success} ) {
19317 return $result->{success};
19318 }
19319 if (defined $result->{systemException}) {
19320 die $result->{systemException};
19321 }
19322 if (defined $result->{notFoundException}) {
19323 die $result->{notFoundException};
19324 }
19325 die "getPublicNotebook failed: unknown result";
19326 }
19327 sub createSharedNotebook{
19328 my $self = shift;
19329 my $authenticationToken = shift;
19330 my $sharedNotebook = shift;
19331  
19332 $self->send_createSharedNotebook($authenticationToken, $sharedNotebook);
19333 return $self->recv_createSharedNotebook();
19334 }
19335  
19336 sub send_createSharedNotebook{
19337 my $self = shift;
19338 my $authenticationToken = shift;
19339 my $sharedNotebook = shift;
19340  
19341 $self->{output}->writeMessageBegin('createSharedNotebook', TMessageType::CALL, $self->{seqid});
19342 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->new();
19343 $args->{authenticationToken} = $authenticationToken;
19344 $args->{sharedNotebook} = $sharedNotebook;
19345 $args->write($self->{output});
19346 $self->{output}->writeMessageEnd();
19347 $self->{output}->getTransport()->flush();
19348 }
19349  
19350 sub recv_createSharedNotebook{
19351 my $self = shift;
19352  
19353 my $rseqid = 0;
19354 my $fname;
19355 my $mtype = 0;
19356  
19357 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19358 if ($mtype == TMessageType::EXCEPTION) {
19359 my $x = TApplicationException->new();
19360 $x->read($self->{input});
19361 $self->{input}->readMessageEnd();
19362 die $x;
19363 }
19364 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->new();
19365 $result->read($self->{input});
19366 $self->{input}->readMessageEnd();
19367  
19368 if (defined $result->{success} ) {
19369 return $result->{success};
19370 }
19371 if (defined $result->{userException}) {
19372 die $result->{userException};
19373 }
19374 if (defined $result->{notFoundException}) {
19375 die $result->{notFoundException};
19376 }
19377 if (defined $result->{systemException}) {
19378 die $result->{systemException};
19379 }
19380 die "createSharedNotebook failed: unknown result";
19381 }
19382 sub sendMessageToSharedNotebookMembers{
19383 my $self = shift;
19384 my $authenticationToken = shift;
19385 my $notebookGuid = shift;
19386 my $messageText = shift;
19387 my $recipients = shift;
19388  
19389 $self->send_sendMessageToSharedNotebookMembers($authenticationToken, $notebookGuid, $messageText, $recipients);
19390 return $self->recv_sendMessageToSharedNotebookMembers();
19391 }
19392  
19393 sub send_sendMessageToSharedNotebookMembers{
19394 my $self = shift;
19395 my $authenticationToken = shift;
19396 my $notebookGuid = shift;
19397 my $messageText = shift;
19398 my $recipients = shift;
19399  
19400 $self->{output}->writeMessageBegin('sendMessageToSharedNotebookMembers', TMessageType::CALL, $self->{seqid});
19401 my $args = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->new();
19402 $args->{authenticationToken} = $authenticationToken;
19403 $args->{notebookGuid} = $notebookGuid;
19404 $args->{messageText} = $messageText;
19405 $args->{recipients} = $recipients;
19406 $args->write($self->{output});
19407 $self->{output}->writeMessageEnd();
19408 $self->{output}->getTransport()->flush();
19409 }
19410  
19411 sub recv_sendMessageToSharedNotebookMembers{
19412 my $self = shift;
19413  
19414 my $rseqid = 0;
19415 my $fname;
19416 my $mtype = 0;
19417  
19418 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19419 if ($mtype == TMessageType::EXCEPTION) {
19420 my $x = TApplicationException->new();
19421 $x->read($self->{input});
19422 $self->{input}->readMessageEnd();
19423 die $x;
19424 }
19425 my $result = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->new();
19426 $result->read($self->{input});
19427 $self->{input}->readMessageEnd();
19428  
19429 if (defined $result->{success} ) {
19430 return $result->{success};
19431 }
19432 if (defined $result->{userException}) {
19433 die $result->{userException};
19434 }
19435 if (defined $result->{notFoundException}) {
19436 die $result->{notFoundException};
19437 }
19438 if (defined $result->{systemException}) {
19439 die $result->{systemException};
19440 }
19441 die "sendMessageToSharedNotebookMembers failed: unknown result";
19442 }
19443 sub listSharedNotebooks{
19444 my $self = shift;
19445 my $authenticationToken = shift;
19446  
19447 $self->send_listSharedNotebooks($authenticationToken);
19448 return $self->recv_listSharedNotebooks();
19449 }
19450  
19451 sub send_listSharedNotebooks{
19452 my $self = shift;
19453 my $authenticationToken = shift;
19454  
19455 $self->{output}->writeMessageBegin('listSharedNotebooks', TMessageType::CALL, $self->{seqid});
19456 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->new();
19457 $args->{authenticationToken} = $authenticationToken;
19458 $args->write($self->{output});
19459 $self->{output}->writeMessageEnd();
19460 $self->{output}->getTransport()->flush();
19461 }
19462  
19463 sub recv_listSharedNotebooks{
19464 my $self = shift;
19465  
19466 my $rseqid = 0;
19467 my $fname;
19468 my $mtype = 0;
19469  
19470 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19471 if ($mtype == TMessageType::EXCEPTION) {
19472 my $x = TApplicationException->new();
19473 $x->read($self->{input});
19474 $self->{input}->readMessageEnd();
19475 die $x;
19476 }
19477 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->new();
19478 $result->read($self->{input});
19479 $self->{input}->readMessageEnd();
19480  
19481 if (defined $result->{success} ) {
19482 return $result->{success};
19483 }
19484 if (defined $result->{userException}) {
19485 die $result->{userException};
19486 }
19487 if (defined $result->{notFoundException}) {
19488 die $result->{notFoundException};
19489 }
19490 if (defined $result->{systemException}) {
19491 die $result->{systemException};
19492 }
19493 die "listSharedNotebooks failed: unknown result";
19494 }
19495 sub expungeSharedNotebooks{
19496 my $self = shift;
19497 my $authenticationToken = shift;
19498 my $sharedNotebookIds = shift;
19499  
19500 $self->send_expungeSharedNotebooks($authenticationToken, $sharedNotebookIds);
19501 return $self->recv_expungeSharedNotebooks();
19502 }
19503  
19504 sub send_expungeSharedNotebooks{
19505 my $self = shift;
19506 my $authenticationToken = shift;
19507 my $sharedNotebookIds = shift;
19508  
19509 $self->{output}->writeMessageBegin('expungeSharedNotebooks', TMessageType::CALL, $self->{seqid});
19510 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->new();
19511 $args->{authenticationToken} = $authenticationToken;
19512 $args->{sharedNotebookIds} = $sharedNotebookIds;
19513 $args->write($self->{output});
19514 $self->{output}->writeMessageEnd();
19515 $self->{output}->getTransport()->flush();
19516 }
19517  
19518 sub recv_expungeSharedNotebooks{
19519 my $self = shift;
19520  
19521 my $rseqid = 0;
19522 my $fname;
19523 my $mtype = 0;
19524  
19525 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19526 if ($mtype == TMessageType::EXCEPTION) {
19527 my $x = TApplicationException->new();
19528 $x->read($self->{input});
19529 $self->{input}->readMessageEnd();
19530 die $x;
19531 }
19532 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->new();
19533 $result->read($self->{input});
19534 $self->{input}->readMessageEnd();
19535  
19536 if (defined $result->{success} ) {
19537 return $result->{success};
19538 }
19539 if (defined $result->{userException}) {
19540 die $result->{userException};
19541 }
19542 if (defined $result->{notFoundException}) {
19543 die $result->{notFoundException};
19544 }
19545 if (defined $result->{systemException}) {
19546 die $result->{systemException};
19547 }
19548 die "expungeSharedNotebooks failed: unknown result";
19549 }
19550 sub createLinkedNotebook{
19551 my $self = shift;
19552 my $authenticationToken = shift;
19553 my $linkedNotebook = shift;
19554  
19555 $self->send_createLinkedNotebook($authenticationToken, $linkedNotebook);
19556 return $self->recv_createLinkedNotebook();
19557 }
19558  
19559 sub send_createLinkedNotebook{
19560 my $self = shift;
19561 my $authenticationToken = shift;
19562 my $linkedNotebook = shift;
19563  
19564 $self->{output}->writeMessageBegin('createLinkedNotebook', TMessageType::CALL, $self->{seqid});
19565 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->new();
19566 $args->{authenticationToken} = $authenticationToken;
19567 $args->{linkedNotebook} = $linkedNotebook;
19568 $args->write($self->{output});
19569 $self->{output}->writeMessageEnd();
19570 $self->{output}->getTransport()->flush();
19571 }
19572  
19573 sub recv_createLinkedNotebook{
19574 my $self = shift;
19575  
19576 my $rseqid = 0;
19577 my $fname;
19578 my $mtype = 0;
19579  
19580 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19581 if ($mtype == TMessageType::EXCEPTION) {
19582 my $x = TApplicationException->new();
19583 $x->read($self->{input});
19584 $self->{input}->readMessageEnd();
19585 die $x;
19586 }
19587 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->new();
19588 $result->read($self->{input});
19589 $self->{input}->readMessageEnd();
19590  
19591 if (defined $result->{success} ) {
19592 return $result->{success};
19593 }
19594 if (defined $result->{userException}) {
19595 die $result->{userException};
19596 }
19597 if (defined $result->{notFoundException}) {
19598 die $result->{notFoundException};
19599 }
19600 if (defined $result->{systemException}) {
19601 die $result->{systemException};
19602 }
19603 die "createLinkedNotebook failed: unknown result";
19604 }
19605 sub updateLinkedNotebook{
19606 my $self = shift;
19607 my $authenticationToken = shift;
19608 my $linkedNotebook = shift;
19609  
19610 $self->send_updateLinkedNotebook($authenticationToken, $linkedNotebook);
19611 return $self->recv_updateLinkedNotebook();
19612 }
19613  
19614 sub send_updateLinkedNotebook{
19615 my $self = shift;
19616 my $authenticationToken = shift;
19617 my $linkedNotebook = shift;
19618  
19619 $self->{output}->writeMessageBegin('updateLinkedNotebook', TMessageType::CALL, $self->{seqid});
19620 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->new();
19621 $args->{authenticationToken} = $authenticationToken;
19622 $args->{linkedNotebook} = $linkedNotebook;
19623 $args->write($self->{output});
19624 $self->{output}->writeMessageEnd();
19625 $self->{output}->getTransport()->flush();
19626 }
19627  
19628 sub recv_updateLinkedNotebook{
19629 my $self = shift;
19630  
19631 my $rseqid = 0;
19632 my $fname;
19633 my $mtype = 0;
19634  
19635 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19636 if ($mtype == TMessageType::EXCEPTION) {
19637 my $x = TApplicationException->new();
19638 $x->read($self->{input});
19639 $self->{input}->readMessageEnd();
19640 die $x;
19641 }
19642 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->new();
19643 $result->read($self->{input});
19644 $self->{input}->readMessageEnd();
19645  
19646 if (defined $result->{success} ) {
19647 return $result->{success};
19648 }
19649 if (defined $result->{userException}) {
19650 die $result->{userException};
19651 }
19652 if (defined $result->{notFoundException}) {
19653 die $result->{notFoundException};
19654 }
19655 if (defined $result->{systemException}) {
19656 die $result->{systemException};
19657 }
19658 die "updateLinkedNotebook failed: unknown result";
19659 }
19660 sub listLinkedNotebooks{
19661 my $self = shift;
19662 my $authenticationToken = shift;
19663  
19664 $self->send_listLinkedNotebooks($authenticationToken);
19665 return $self->recv_listLinkedNotebooks();
19666 }
19667  
19668 sub send_listLinkedNotebooks{
19669 my $self = shift;
19670 my $authenticationToken = shift;
19671  
19672 $self->{output}->writeMessageBegin('listLinkedNotebooks', TMessageType::CALL, $self->{seqid});
19673 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->new();
19674 $args->{authenticationToken} = $authenticationToken;
19675 $args->write($self->{output});
19676 $self->{output}->writeMessageEnd();
19677 $self->{output}->getTransport()->flush();
19678 }
19679  
19680 sub recv_listLinkedNotebooks{
19681 my $self = shift;
19682  
19683 my $rseqid = 0;
19684 my $fname;
19685 my $mtype = 0;
19686  
19687 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19688 if ($mtype == TMessageType::EXCEPTION) {
19689 my $x = TApplicationException->new();
19690 $x->read($self->{input});
19691 $self->{input}->readMessageEnd();
19692 die $x;
19693 }
19694 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->new();
19695 $result->read($self->{input});
19696 $self->{input}->readMessageEnd();
19697  
19698 if (defined $result->{success} ) {
19699 return $result->{success};
19700 }
19701 if (defined $result->{userException}) {
19702 die $result->{userException};
19703 }
19704 if (defined $result->{notFoundException}) {
19705 die $result->{notFoundException};
19706 }
19707 if (defined $result->{systemException}) {
19708 die $result->{systemException};
19709 }
19710 die "listLinkedNotebooks failed: unknown result";
19711 }
19712 sub expungeLinkedNotebook{
19713 my $self = shift;
19714 my $authenticationToken = shift;
19715 my $guid = shift;
19716  
19717 $self->send_expungeLinkedNotebook($authenticationToken, $guid);
19718 return $self->recv_expungeLinkedNotebook();
19719 }
19720  
19721 sub send_expungeLinkedNotebook{
19722 my $self = shift;
19723 my $authenticationToken = shift;
19724 my $guid = shift;
19725  
19726 $self->{output}->writeMessageBegin('expungeLinkedNotebook', TMessageType::CALL, $self->{seqid});
19727 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->new();
19728 $args->{authenticationToken} = $authenticationToken;
19729 $args->{guid} = $guid;
19730 $args->write($self->{output});
19731 $self->{output}->writeMessageEnd();
19732 $self->{output}->getTransport()->flush();
19733 }
19734  
19735 sub recv_expungeLinkedNotebook{
19736 my $self = shift;
19737  
19738 my $rseqid = 0;
19739 my $fname;
19740 my $mtype = 0;
19741  
19742 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19743 if ($mtype == TMessageType::EXCEPTION) {
19744 my $x = TApplicationException->new();
19745 $x->read($self->{input});
19746 $self->{input}->readMessageEnd();
19747 die $x;
19748 }
19749 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->new();
19750 $result->read($self->{input});
19751 $self->{input}->readMessageEnd();
19752  
19753 if (defined $result->{success} ) {
19754 return $result->{success};
19755 }
19756 if (defined $result->{userException}) {
19757 die $result->{userException};
19758 }
19759 if (defined $result->{notFoundException}) {
19760 die $result->{notFoundException};
19761 }
19762 if (defined $result->{systemException}) {
19763 die $result->{systemException};
19764 }
19765 die "expungeLinkedNotebook failed: unknown result";
19766 }
19767 sub authenticateToSharedNotebook{
19768 my $self = shift;
19769 my $shareKey = shift;
19770 my $authenticationToken = shift;
19771  
19772 $self->send_authenticateToSharedNotebook($shareKey, $authenticationToken);
19773 return $self->recv_authenticateToSharedNotebook();
19774 }
19775  
19776 sub send_authenticateToSharedNotebook{
19777 my $self = shift;
19778 my $shareKey = shift;
19779 my $authenticationToken = shift;
19780  
19781 $self->{output}->writeMessageBegin('authenticateToSharedNotebook', TMessageType::CALL, $self->{seqid});
19782 my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->new();
19783 $args->{shareKey} = $shareKey;
19784 $args->{authenticationToken} = $authenticationToken;
19785 $args->write($self->{output});
19786 $self->{output}->writeMessageEnd();
19787 $self->{output}->getTransport()->flush();
19788 }
19789  
19790 sub recv_authenticateToSharedNotebook{
19791 my $self = shift;
19792  
19793 my $rseqid = 0;
19794 my $fname;
19795 my $mtype = 0;
19796  
19797 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19798 if ($mtype == TMessageType::EXCEPTION) {
19799 my $x = TApplicationException->new();
19800 $x->read($self->{input});
19801 $self->{input}->readMessageEnd();
19802 die $x;
19803 }
19804 my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->new();
19805 $result->read($self->{input});
19806 $self->{input}->readMessageEnd();
19807  
19808 if (defined $result->{success} ) {
19809 return $result->{success};
19810 }
19811 if (defined $result->{userException}) {
19812 die $result->{userException};
19813 }
19814 if (defined $result->{notFoundException}) {
19815 die $result->{notFoundException};
19816 }
19817 if (defined $result->{systemException}) {
19818 die $result->{systemException};
19819 }
19820 die "authenticateToSharedNotebook failed: unknown result";
19821 }
19822 sub getSharedNotebookByAuth{
19823 my $self = shift;
19824 my $authenticationToken = shift;
19825  
19826 $self->send_getSharedNotebookByAuth($authenticationToken);
19827 return $self->recv_getSharedNotebookByAuth();
19828 }
19829  
19830 sub send_getSharedNotebookByAuth{
19831 my $self = shift;
19832 my $authenticationToken = shift;
19833  
19834 $self->{output}->writeMessageBegin('getSharedNotebookByAuth', TMessageType::CALL, $self->{seqid});
19835 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->new();
19836 $args->{authenticationToken} = $authenticationToken;
19837 $args->write($self->{output});
19838 $self->{output}->writeMessageEnd();
19839 $self->{output}->getTransport()->flush();
19840 }
19841  
19842 sub recv_getSharedNotebookByAuth{
19843 my $self = shift;
19844  
19845 my $rseqid = 0;
19846 my $fname;
19847 my $mtype = 0;
19848  
19849 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19850 if ($mtype == TMessageType::EXCEPTION) {
19851 my $x = TApplicationException->new();
19852 $x->read($self->{input});
19853 $self->{input}->readMessageEnd();
19854 die $x;
19855 }
19856 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->new();
19857 $result->read($self->{input});
19858 $self->{input}->readMessageEnd();
19859  
19860 if (defined $result->{success} ) {
19861 return $result->{success};
19862 }
19863 if (defined $result->{userException}) {
19864 die $result->{userException};
19865 }
19866 if (defined $result->{notFoundException}) {
19867 die $result->{notFoundException};
19868 }
19869 if (defined $result->{systemException}) {
19870 die $result->{systemException};
19871 }
19872 die "getSharedNotebookByAuth failed: unknown result";
19873 }
19874 sub emailNote{
19875 my $self = shift;
19876 my $authenticationToken = shift;
19877 my $parameters = shift;
19878  
19879 $self->send_emailNote($authenticationToken, $parameters);
19880 $self->recv_emailNote();
19881 }
19882  
19883 sub send_emailNote{
19884 my $self = shift;
19885 my $authenticationToken = shift;
19886 my $parameters = shift;
19887  
19888 $self->{output}->writeMessageBegin('emailNote', TMessageType::CALL, $self->{seqid});
19889 my $args = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->new();
19890 $args->{authenticationToken} = $authenticationToken;
19891 $args->{parameters} = $parameters;
19892 $args->write($self->{output});
19893 $self->{output}->writeMessageEnd();
19894 $self->{output}->getTransport()->flush();
19895 }
19896  
19897 sub recv_emailNote{
19898 my $self = shift;
19899  
19900 my $rseqid = 0;
19901 my $fname;
19902 my $mtype = 0;
19903  
19904 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19905 if ($mtype == TMessageType::EXCEPTION) {
19906 my $x = TApplicationException->new();
19907 $x->read($self->{input});
19908 $self->{input}->readMessageEnd();
19909 die $x;
19910 }
19911 my $result = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->new();
19912 $result->read($self->{input});
19913 $self->{input}->readMessageEnd();
19914  
19915 if (defined $result->{userException}) {
19916 die $result->{userException};
19917 }
19918 if (defined $result->{notFoundException}) {
19919 die $result->{notFoundException};
19920 }
19921 if (defined $result->{systemException}) {
19922 die $result->{systemException};
19923 }
19924 return;
19925 }
19926 sub shareNote{
19927 my $self = shift;
19928 my $authenticationToken = shift;
19929 my $guid = shift;
19930  
19931 $self->send_shareNote($authenticationToken, $guid);
19932 return $self->recv_shareNote();
19933 }
19934  
19935 sub send_shareNote{
19936 my $self = shift;
19937 my $authenticationToken = shift;
19938 my $guid = shift;
19939  
19940 $self->{output}->writeMessageBegin('shareNote', TMessageType::CALL, $self->{seqid});
19941 my $args = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->new();
19942 $args->{authenticationToken} = $authenticationToken;
19943 $args->{guid} = $guid;
19944 $args->write($self->{output});
19945 $self->{output}->writeMessageEnd();
19946 $self->{output}->getTransport()->flush();
19947 }
19948  
19949 sub recv_shareNote{
19950 my $self = shift;
19951  
19952 my $rseqid = 0;
19953 my $fname;
19954 my $mtype = 0;
19955  
19956 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
19957 if ($mtype == TMessageType::EXCEPTION) {
19958 my $x = TApplicationException->new();
19959 $x->read($self->{input});
19960 $self->{input}->readMessageEnd();
19961 die $x;
19962 }
19963 my $result = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->new();
19964 $result->read($self->{input});
19965 $self->{input}->readMessageEnd();
19966  
19967 if (defined $result->{success} ) {
19968 return $result->{success};
19969 }
19970 if (defined $result->{userException}) {
19971 die $result->{userException};
19972 }
19973 if (defined $result->{notFoundException}) {
19974 die $result->{notFoundException};
19975 }
19976 if (defined $result->{systemException}) {
19977 die $result->{systemException};
19978 }
19979 die "shareNote failed: unknown result";
19980 }
19981 sub stopSharingNote{
19982 my $self = shift;
19983 my $authenticationToken = shift;
19984 my $guid = shift;
19985  
19986 $self->send_stopSharingNote($authenticationToken, $guid);
19987 $self->recv_stopSharingNote();
19988 }
19989  
19990 sub send_stopSharingNote{
19991 my $self = shift;
19992 my $authenticationToken = shift;
19993 my $guid = shift;
19994  
19995 $self->{output}->writeMessageBegin('stopSharingNote', TMessageType::CALL, $self->{seqid});
19996 my $args = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->new();
19997 $args->{authenticationToken} = $authenticationToken;
19998 $args->{guid} = $guid;
19999 $args->write($self->{output});
20000 $self->{output}->writeMessageEnd();
20001 $self->{output}->getTransport()->flush();
20002 }
20003  
20004 sub recv_stopSharingNote{
20005 my $self = shift;
20006  
20007 my $rseqid = 0;
20008 my $fname;
20009 my $mtype = 0;
20010  
20011 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
20012 if ($mtype == TMessageType::EXCEPTION) {
20013 my $x = TApplicationException->new();
20014 $x->read($self->{input});
20015 $self->{input}->readMessageEnd();
20016 die $x;
20017 }
20018 my $result = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->new();
20019 $result->read($self->{input});
20020 $self->{input}->readMessageEnd();
20021  
20022 if (defined $result->{userException}) {
20023 die $result->{userException};
20024 }
20025 if (defined $result->{notFoundException}) {
20026 die $result->{notFoundException};
20027 }
20028 if (defined $result->{systemException}) {
20029 die $result->{systemException};
20030 }
20031 return;
20032 }
20033 sub authenticateToSharedNote{
20034 my $self = shift;
20035 my $guid = shift;
20036 my $noteKey = shift;
20037  
20038 $self->send_authenticateToSharedNote($guid, $noteKey);
20039 return $self->recv_authenticateToSharedNote();
20040 }
20041  
20042 sub send_authenticateToSharedNote{
20043 my $self = shift;
20044 my $guid = shift;
20045 my $noteKey = shift;
20046  
20047 $self->{output}->writeMessageBegin('authenticateToSharedNote', TMessageType::CALL, $self->{seqid});
20048 my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->new();
20049 $args->{guid} = $guid;
20050 $args->{noteKey} = $noteKey;
20051 $args->write($self->{output});
20052 $self->{output}->writeMessageEnd();
20053 $self->{output}->getTransport()->flush();
20054 }
20055  
20056 sub recv_authenticateToSharedNote{
20057 my $self = shift;
20058  
20059 my $rseqid = 0;
20060 my $fname;
20061 my $mtype = 0;
20062  
20063 $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
20064 if ($mtype == TMessageType::EXCEPTION) {
20065 my $x = TApplicationException->new();
20066 $x->read($self->{input});
20067 $self->{input}->readMessageEnd();
20068 die $x;
20069 }
20070 my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->new();
20071 $result->read($self->{input});
20072 $self->{input}->readMessageEnd();
20073  
20074 if (defined $result->{success} ) {
20075 return $result->{success};
20076 }
20077 if (defined $result->{userException}) {
20078 die $result->{userException};
20079 }
20080 if (defined $result->{notFoundException}) {
20081 die $result->{notFoundException};
20082 }
20083 if (defined $result->{systemException}) {
20084 die $result->{systemException};
20085 }
20086 die "authenticateToSharedNote failed: unknown result";
20087 }
20088 package Net::Evernote::EDAMNoteStore::NoteStoreProcessor;
20089  
20090 use strict;
20091  
20092  
20093 sub new {
20094 my ($classname, $handler) = @_;
20095 my $self = {};
20096 $self->{handler} = $handler;
20097 return bless ($self, $classname);
20098 }
20099  
20100 sub process {
20101 my ($self, $input, $output) = @_;
20102 my $rseqid = 0;
20103 my $fname = undef;
20104 my $mtype = 0;
20105  
20106 $input->readMessageBegin(\$fname, \$mtype, \$rseqid);
20107 my $methodname = 'process_'.$fname;
20108 if (!$self->can($methodname)) {
20109 $input->skip(TType::STRUCT);
20110 $input->readMessageEnd();
20111 my $x = TApplicationException->new('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
20112 $output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
20113 $x->write($output);
20114 $output->writeMessageEnd();
20115 $output->getTransport()->flush();
20116 return;
20117 }
20118 $self->$methodname($rseqid, $input, $output);
20119 return 1;
20120 }
20121  
20122 sub process_getSyncState {
20123 my ($self, $seqid, $input, $output) = @_;
20124 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_args->new();
20125 $args->read($input);
20126 $input->readMessageEnd();
20127 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncState_result->new();
20128 eval {
20129 $result->{success} = $self->{handler}->getSyncState($args->authenticationToken);
20130 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20131 $result->{userException} = $@;
20132 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20133 $result->{systemException} = $@;
20134 }
20135 $output->writeMessageBegin('getSyncState', TMessageType::REPLY, $seqid);
20136 $result->write($output);
20137 $output->writeMessageEnd();
20138 $output->getTransport()->flush();
20139 }
20140  
20141 sub process_getSyncChunk {
20142 my ($self, $seqid, $input, $output) = @_;
20143 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_args->new();
20144 $args->read($input);
20145 $input->readMessageEnd();
20146 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSyncChunk_result->new();
20147 eval {
20148 $result->{success} = $self->{handler}->getSyncChunk($args->authenticationToken, $args->afterUSN, $args->maxEntries, $args->fullSyncOnly);
20149 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20150 $result->{userException} = $@;
20151 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20152 $result->{systemException} = $@;
20153 }
20154 $output->writeMessageBegin('getSyncChunk', TMessageType::REPLY, $seqid);
20155 $result->write($output);
20156 $output->writeMessageEnd();
20157 $output->getTransport()->flush();
20158 }
20159  
20160 sub process_getFilteredSyncChunk {
20161 my ($self, $seqid, $input, $output) = @_;
20162 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_args->new();
20163 $args->read($input);
20164 $input->readMessageEnd();
20165 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getFilteredSyncChunk_result->new();
20166 eval {
20167 $result->{success} = $self->{handler}->getFilteredSyncChunk($args->authenticationToken, $args->afterUSN, $args->maxEntries, $args->filter);
20168 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20169 $result->{userException} = $@;
20170 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20171 $result->{systemException} = $@;
20172 }
20173 $output->writeMessageBegin('getFilteredSyncChunk', TMessageType::REPLY, $seqid);
20174 $result->write($output);
20175 $output->writeMessageEnd();
20176 $output->getTransport()->flush();
20177 }
20178  
20179 sub process_getLinkedNotebookSyncState {
20180 my ($self, $seqid, $input, $output) = @_;
20181 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_args->new();
20182 $args->read($input);
20183 $input->readMessageEnd();
20184 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncState_result->new();
20185 eval {
20186 $result->{success} = $self->{handler}->getLinkedNotebookSyncState($args->authenticationToken, $args->linkedNotebook);
20187 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20188 $result->{userException} = $@;
20189 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20190 $result->{systemException} = $@;
20191 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20192 $result->{notFoundException} = $@;
20193 }
20194 $output->writeMessageBegin('getLinkedNotebookSyncState', TMessageType::REPLY, $seqid);
20195 $result->write($output);
20196 $output->writeMessageEnd();
20197 $output->getTransport()->flush();
20198 }
20199  
20200 sub process_getLinkedNotebookSyncChunk {
20201 my ($self, $seqid, $input, $output) = @_;
20202 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_args->new();
20203 $args->read($input);
20204 $input->readMessageEnd();
20205 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getLinkedNotebookSyncChunk_result->new();
20206 eval {
20207 $result->{success} = $self->{handler}->getLinkedNotebookSyncChunk($args->authenticationToken, $args->linkedNotebook, $args->afterUSN, $args->maxEntries, $args->fullSyncOnly);
20208 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20209 $result->{userException} = $@;
20210 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20211 $result->{systemException} = $@;
20212 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20213 $result->{notFoundException} = $@;
20214 }
20215 $output->writeMessageBegin('getLinkedNotebookSyncChunk', TMessageType::REPLY, $seqid);
20216 $result->write($output);
20217 $output->writeMessageEnd();
20218 $output->getTransport()->flush();
20219 }
20220  
20221 sub process_listNotebooks {
20222 my ($self, $seqid, $input, $output) = @_;
20223 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_args->new();
20224 $args->read($input);
20225 $input->readMessageEnd();
20226 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNotebooks_result->new();
20227 eval {
20228 $result->{success} = $self->{handler}->listNotebooks($args->authenticationToken);
20229 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20230 $result->{userException} = $@;
20231 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20232 $result->{systemException} = $@;
20233 }
20234 $output->writeMessageBegin('listNotebooks', TMessageType::REPLY, $seqid);
20235 $result->write($output);
20236 $output->writeMessageEnd();
20237 $output->getTransport()->flush();
20238 }
20239  
20240 sub process_getNotebook {
20241 my ($self, $seqid, $input, $output) = @_;
20242 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_args->new();
20243 $args->read($input);
20244 $input->readMessageEnd();
20245 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNotebook_result->new();
20246 eval {
20247 $result->{success} = $self->{handler}->getNotebook($args->authenticationToken, $args->guid);
20248 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20249 $result->{userException} = $@;
20250 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20251 $result->{systemException} = $@;
20252 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20253 $result->{notFoundException} = $@;
20254 }
20255 $output->writeMessageBegin('getNotebook', TMessageType::REPLY, $seqid);
20256 $result->write($output);
20257 $output->writeMessageEnd();
20258 $output->getTransport()->flush();
20259 }
20260  
20261 sub process_getDefaultNotebook {
20262 my ($self, $seqid, $input, $output) = @_;
20263 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_args->new();
20264 $args->read($input);
20265 $input->readMessageEnd();
20266 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getDefaultNotebook_result->new();
20267 eval {
20268 $result->{success} = $self->{handler}->getDefaultNotebook($args->authenticationToken);
20269 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20270 $result->{userException} = $@;
20271 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20272 $result->{systemException} = $@;
20273 }
20274 $output->writeMessageBegin('getDefaultNotebook', TMessageType::REPLY, $seqid);
20275 $result->write($output);
20276 $output->writeMessageEnd();
20277 $output->getTransport()->flush();
20278 }
20279  
20280 sub process_createNotebook {
20281 my ($self, $seqid, $input, $output) = @_;
20282 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_args->new();
20283 $args->read($input);
20284 $input->readMessageEnd();
20285 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNotebook_result->new();
20286 eval {
20287 $result->{success} = $self->{handler}->createNotebook($args->authenticationToken, $args->notebook);
20288 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20289 $result->{userException} = $@;
20290 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20291 $result->{systemException} = $@;
20292 }
20293 $output->writeMessageBegin('createNotebook', TMessageType::REPLY, $seqid);
20294 $result->write($output);
20295 $output->writeMessageEnd();
20296 $output->getTransport()->flush();
20297 }
20298  
20299 sub process_updateNotebook {
20300 my ($self, $seqid, $input, $output) = @_;
20301 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_args->new();
20302 $args->read($input);
20303 $input->readMessageEnd();
20304 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNotebook_result->new();
20305 eval {
20306 $result->{success} = $self->{handler}->updateNotebook($args->authenticationToken, $args->notebook);
20307 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20308 $result->{userException} = $@;
20309 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20310 $result->{systemException} = $@;
20311 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20312 $result->{notFoundException} = $@;
20313 }
20314 $output->writeMessageBegin('updateNotebook', TMessageType::REPLY, $seqid);
20315 $result->write($output);
20316 $output->writeMessageEnd();
20317 $output->getTransport()->flush();
20318 }
20319  
20320 sub process_expungeNotebook {
20321 my ($self, $seqid, $input, $output) = @_;
20322 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_args->new();
20323 $args->read($input);
20324 $input->readMessageEnd();
20325 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotebook_result->new();
20326 eval {
20327 $result->{success} = $self->{handler}->expungeNotebook($args->authenticationToken, $args->guid);
20328 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20329 $result->{userException} = $@;
20330 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20331 $result->{systemException} = $@;
20332 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20333 $result->{notFoundException} = $@;
20334 }
20335 $output->writeMessageBegin('expungeNotebook', TMessageType::REPLY, $seqid);
20336 $result->write($output);
20337 $output->writeMessageEnd();
20338 $output->getTransport()->flush();
20339 }
20340  
20341 sub process_listTags {
20342 my ($self, $seqid, $input, $output) = @_;
20343 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTags_args->new();
20344 $args->read($input);
20345 $input->readMessageEnd();
20346 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTags_result->new();
20347 eval {
20348 $result->{success} = $self->{handler}->listTags($args->authenticationToken);
20349 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20350 $result->{userException} = $@;
20351 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20352 $result->{systemException} = $@;
20353 }
20354 $output->writeMessageBegin('listTags', TMessageType::REPLY, $seqid);
20355 $result->write($output);
20356 $output->writeMessageEnd();
20357 $output->getTransport()->flush();
20358 }
20359  
20360 sub process_listTagsByNotebook {
20361 my ($self, $seqid, $input, $output) = @_;
20362 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_args->new();
20363 $args->read($input);
20364 $input->readMessageEnd();
20365 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listTagsByNotebook_result->new();
20366 eval {
20367 $result->{success} = $self->{handler}->listTagsByNotebook($args->authenticationToken, $args->notebookGuid);
20368 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20369 $result->{userException} = $@;
20370 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20371 $result->{systemException} = $@;
20372 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20373 $result->{notFoundException} = $@;
20374 }
20375 $output->writeMessageBegin('listTagsByNotebook', TMessageType::REPLY, $seqid);
20376 $result->write($output);
20377 $output->writeMessageEnd();
20378 $output->getTransport()->flush();
20379 }
20380  
20381 sub process_getTag {
20382 my ($self, $seqid, $input, $output) = @_;
20383 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getTag_args->new();
20384 $args->read($input);
20385 $input->readMessageEnd();
20386 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getTag_result->new();
20387 eval {
20388 $result->{success} = $self->{handler}->getTag($args->authenticationToken, $args->guid);
20389 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20390 $result->{userException} = $@;
20391 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20392 $result->{systemException} = $@;
20393 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20394 $result->{notFoundException} = $@;
20395 }
20396 $output->writeMessageBegin('getTag', TMessageType::REPLY, $seqid);
20397 $result->write($output);
20398 $output->writeMessageEnd();
20399 $output->getTransport()->flush();
20400 }
20401  
20402 sub process_createTag {
20403 my ($self, $seqid, $input, $output) = @_;
20404 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createTag_args->new();
20405 $args->read($input);
20406 $input->readMessageEnd();
20407 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createTag_result->new();
20408 eval {
20409 $result->{success} = $self->{handler}->createTag($args->authenticationToken, $args->tag);
20410 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20411 $result->{userException} = $@;
20412 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20413 $result->{systemException} = $@;
20414 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20415 $result->{notFoundException} = $@;
20416 }
20417 $output->writeMessageBegin('createTag', TMessageType::REPLY, $seqid);
20418 $result->write($output);
20419 $output->writeMessageEnd();
20420 $output->getTransport()->flush();
20421 }
20422  
20423 sub process_updateTag {
20424 my ($self, $seqid, $input, $output) = @_;
20425 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_args->new();
20426 $args->read($input);
20427 $input->readMessageEnd();
20428 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateTag_result->new();
20429 eval {
20430 $result->{success} = $self->{handler}->updateTag($args->authenticationToken, $args->tag);
20431 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20432 $result->{userException} = $@;
20433 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20434 $result->{systemException} = $@;
20435 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20436 $result->{notFoundException} = $@;
20437 }
20438 $output->writeMessageBegin('updateTag', TMessageType::REPLY, $seqid);
20439 $result->write($output);
20440 $output->writeMessageEnd();
20441 $output->getTransport()->flush();
20442 }
20443  
20444 sub process_untagAll {
20445 my ($self, $seqid, $input, $output) = @_;
20446 my $args = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_args->new();
20447 $args->read($input);
20448 $input->readMessageEnd();
20449 my $result = Net::Evernote::EDAMNoteStore::NoteStore_untagAll_result->new();
20450 eval {
20451 $self->{handler}->untagAll($args->authenticationToken, $args->guid);
20452 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20453 $result->{userException} = $@;
20454 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20455 $result->{systemException} = $@;
20456 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20457 $result->{notFoundException} = $@;
20458 }
20459 $output->writeMessageBegin('untagAll', TMessageType::REPLY, $seqid);
20460 $result->write($output);
20461 $output->writeMessageEnd();
20462 $output->getTransport()->flush();
20463 }
20464  
20465 sub process_expungeTag {
20466 my ($self, $seqid, $input, $output) = @_;
20467 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_args->new();
20468 $args->read($input);
20469 $input->readMessageEnd();
20470 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeTag_result->new();
20471 eval {
20472 $result->{success} = $self->{handler}->expungeTag($args->authenticationToken, $args->guid);
20473 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20474 $result->{userException} = $@;
20475 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20476 $result->{systemException} = $@;
20477 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20478 $result->{notFoundException} = $@;
20479 }
20480 $output->writeMessageBegin('expungeTag', TMessageType::REPLY, $seqid);
20481 $result->write($output);
20482 $output->writeMessageEnd();
20483 $output->getTransport()->flush();
20484 }
20485  
20486 sub process_listSearches {
20487 my ($self, $seqid, $input, $output) = @_;
20488 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_args->new();
20489 $args->read($input);
20490 $input->readMessageEnd();
20491 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSearches_result->new();
20492 eval {
20493 $result->{success} = $self->{handler}->listSearches($args->authenticationToken);
20494 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20495 $result->{userException} = $@;
20496 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20497 $result->{systemException} = $@;
20498 }
20499 $output->writeMessageBegin('listSearches', TMessageType::REPLY, $seqid);
20500 $result->write($output);
20501 $output->writeMessageEnd();
20502 $output->getTransport()->flush();
20503 }
20504  
20505 sub process_getSearch {
20506 my ($self, $seqid, $input, $output) = @_;
20507 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_args->new();
20508 $args->read($input);
20509 $input->readMessageEnd();
20510 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSearch_result->new();
20511 eval {
20512 $result->{success} = $self->{handler}->getSearch($args->authenticationToken, $args->guid);
20513 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20514 $result->{userException} = $@;
20515 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20516 $result->{systemException} = $@;
20517 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20518 $result->{notFoundException} = $@;
20519 }
20520 $output->writeMessageBegin('getSearch', TMessageType::REPLY, $seqid);
20521 $result->write($output);
20522 $output->writeMessageEnd();
20523 $output->getTransport()->flush();
20524 }
20525  
20526 sub process_createSearch {
20527 my ($self, $seqid, $input, $output) = @_;
20528 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_args->new();
20529 $args->read($input);
20530 $input->readMessageEnd();
20531 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSearch_result->new();
20532 eval {
20533 $result->{success} = $self->{handler}->createSearch($args->authenticationToken, $args->search);
20534 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20535 $result->{userException} = $@;
20536 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20537 $result->{systemException} = $@;
20538 }
20539 $output->writeMessageBegin('createSearch', TMessageType::REPLY, $seqid);
20540 $result->write($output);
20541 $output->writeMessageEnd();
20542 $output->getTransport()->flush();
20543 }
20544  
20545 sub process_updateSearch {
20546 my ($self, $seqid, $input, $output) = @_;
20547 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_args->new();
20548 $args->read($input);
20549 $input->readMessageEnd();
20550 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateSearch_result->new();
20551 eval {
20552 $result->{success} = $self->{handler}->updateSearch($args->authenticationToken, $args->search);
20553 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20554 $result->{userException} = $@;
20555 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20556 $result->{systemException} = $@;
20557 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20558 $result->{notFoundException} = $@;
20559 }
20560 $output->writeMessageBegin('updateSearch', TMessageType::REPLY, $seqid);
20561 $result->write($output);
20562 $output->writeMessageEnd();
20563 $output->getTransport()->flush();
20564 }
20565  
20566 sub process_expungeSearch {
20567 my ($self, $seqid, $input, $output) = @_;
20568 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_args->new();
20569 $args->read($input);
20570 $input->readMessageEnd();
20571 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSearch_result->new();
20572 eval {
20573 $result->{success} = $self->{handler}->expungeSearch($args->authenticationToken, $args->guid);
20574 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20575 $result->{userException} = $@;
20576 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20577 $result->{systemException} = $@;
20578 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20579 $result->{notFoundException} = $@;
20580 }
20581 $output->writeMessageBegin('expungeSearch', TMessageType::REPLY, $seqid);
20582 $result->write($output);
20583 $output->writeMessageEnd();
20584 $output->getTransport()->flush();
20585 }
20586  
20587 sub process_findNotes {
20588 my ($self, $seqid, $input, $output) = @_;
20589 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_args->new();
20590 $args->read($input);
20591 $input->readMessageEnd();
20592 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotes_result->new();
20593 eval {
20594 $result->{success} = $self->{handler}->findNotes($args->authenticationToken, $args->filter, $args->offset, $args->maxNotes);
20595 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20596 $result->{userException} = $@;
20597 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20598 $result->{systemException} = $@;
20599 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20600 $result->{notFoundException} = $@;
20601 }
20602 $output->writeMessageBegin('findNotes', TMessageType::REPLY, $seqid);
20603 $result->write($output);
20604 $output->writeMessageEnd();
20605 $output->getTransport()->flush();
20606 }
20607  
20608 sub process_findNoteOffset {
20609 my ($self, $seqid, $input, $output) = @_;
20610 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_args->new();
20611 $args->read($input);
20612 $input->readMessageEnd();
20613 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteOffset_result->new();
20614 eval {
20615 $result->{success} = $self->{handler}->findNoteOffset($args->authenticationToken, $args->filter, $args->guid);
20616 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20617 $result->{userException} = $@;
20618 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20619 $result->{systemException} = $@;
20620 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20621 $result->{notFoundException} = $@;
20622 }
20623 $output->writeMessageBegin('findNoteOffset', TMessageType::REPLY, $seqid);
20624 $result->write($output);
20625 $output->writeMessageEnd();
20626 $output->getTransport()->flush();
20627 }
20628  
20629 sub process_findNotesMetadata {
20630 my ($self, $seqid, $input, $output) = @_;
20631 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_args->new();
20632 $args->read($input);
20633 $input->readMessageEnd();
20634 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNotesMetadata_result->new();
20635 eval {
20636 $result->{success} = $self->{handler}->findNotesMetadata($args->authenticationToken, $args->filter, $args->offset, $args->maxNotes, $args->resultSpec);
20637 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20638 $result->{userException} = $@;
20639 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20640 $result->{systemException} = $@;
20641 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20642 $result->{notFoundException} = $@;
20643 }
20644 $output->writeMessageBegin('findNotesMetadata', TMessageType::REPLY, $seqid);
20645 $result->write($output);
20646 $output->writeMessageEnd();
20647 $output->getTransport()->flush();
20648 }
20649  
20650 sub process_findNoteCounts {
20651 my ($self, $seqid, $input, $output) = @_;
20652 my $args = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_args->new();
20653 $args->read($input);
20654 $input->readMessageEnd();
20655 my $result = Net::Evernote::EDAMNoteStore::NoteStore_findNoteCounts_result->new();
20656 eval {
20657 $result->{success} = $self->{handler}->findNoteCounts($args->authenticationToken, $args->filter, $args->withTrash);
20658 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20659 $result->{userException} = $@;
20660 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20661 $result->{systemException} = $@;
20662 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20663 $result->{notFoundException} = $@;
20664 }
20665 $output->writeMessageBegin('findNoteCounts', TMessageType::REPLY, $seqid);
20666 $result->write($output);
20667 $output->writeMessageEnd();
20668 $output->getTransport()->flush();
20669 }
20670  
20671 sub process_getNote {
20672 my ($self, $seqid, $input, $output) = @_;
20673 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNote_args->new();
20674 $args->read($input);
20675 $input->readMessageEnd();
20676 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNote_result->new();
20677 eval {
20678 $result->{success} = $self->{handler}->getNote($args->authenticationToken, $args->guid, $args->withContent, $args->withResourcesData, $args->withResourcesRecognition, $args->withResourcesAlternateData);
20679 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20680 $result->{userException} = $@;
20681 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20682 $result->{systemException} = $@;
20683 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20684 $result->{notFoundException} = $@;
20685 }
20686 $output->writeMessageBegin('getNote', TMessageType::REPLY, $seqid);
20687 $result->write($output);
20688 $output->writeMessageEnd();
20689 $output->getTransport()->flush();
20690 }
20691  
20692 sub process_getNoteApplicationData {
20693 my ($self, $seqid, $input, $output) = @_;
20694 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_args->new();
20695 $args->read($input);
20696 $input->readMessageEnd();
20697 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationData_result->new();
20698 eval {
20699 $result->{success} = $self->{handler}->getNoteApplicationData($args->authenticationToken, $args->guid);
20700 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20701 $result->{userException} = $@;
20702 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20703 $result->{systemException} = $@;
20704 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20705 $result->{notFoundException} = $@;
20706 }
20707 $output->writeMessageBegin('getNoteApplicationData', TMessageType::REPLY, $seqid);
20708 $result->write($output);
20709 $output->writeMessageEnd();
20710 $output->getTransport()->flush();
20711 }
20712  
20713 sub process_getNoteApplicationDataEntry {
20714 my ($self, $seqid, $input, $output) = @_;
20715 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_args->new();
20716 $args->read($input);
20717 $input->readMessageEnd();
20718 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteApplicationDataEntry_result->new();
20719 eval {
20720 $result->{success} = $self->{handler}->getNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
20721 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20722 $result->{userException} = $@;
20723 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20724 $result->{systemException} = $@;
20725 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20726 $result->{notFoundException} = $@;
20727 }
20728 $output->writeMessageBegin('getNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
20729 $result->write($output);
20730 $output->writeMessageEnd();
20731 $output->getTransport()->flush();
20732 }
20733  
20734 sub process_setNoteApplicationDataEntry {
20735 my ($self, $seqid, $input, $output) = @_;
20736 my $args = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_args->new();
20737 $args->read($input);
20738 $input->readMessageEnd();
20739 my $result = Net::Evernote::EDAMNoteStore::NoteStore_setNoteApplicationDataEntry_result->new();
20740 eval {
20741 $result->{success} = $self->{handler}->setNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key, $args->value);
20742 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20743 $result->{userException} = $@;
20744 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20745 $result->{systemException} = $@;
20746 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20747 $result->{notFoundException} = $@;
20748 }
20749 $output->writeMessageBegin('setNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
20750 $result->write($output);
20751 $output->writeMessageEnd();
20752 $output->getTransport()->flush();
20753 }
20754  
20755 sub process_unsetNoteApplicationDataEntry {
20756 my ($self, $seqid, $input, $output) = @_;
20757 my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_args->new();
20758 $args->read($input);
20759 $input->readMessageEnd();
20760 my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetNoteApplicationDataEntry_result->new();
20761 eval {
20762 $result->{success} = $self->{handler}->unsetNoteApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
20763 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20764 $result->{userException} = $@;
20765 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20766 $result->{systemException} = $@;
20767 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20768 $result->{notFoundException} = $@;
20769 }
20770 $output->writeMessageBegin('unsetNoteApplicationDataEntry', TMessageType::REPLY, $seqid);
20771 $result->write($output);
20772 $output->writeMessageEnd();
20773 $output->getTransport()->flush();
20774 }
20775  
20776 sub process_getNoteContent {
20777 my ($self, $seqid, $input, $output) = @_;
20778 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_args->new();
20779 $args->read($input);
20780 $input->readMessageEnd();
20781 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteContent_result->new();
20782 eval {
20783 $result->{success} = $self->{handler}->getNoteContent($args->authenticationToken, $args->guid);
20784 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20785 $result->{userException} = $@;
20786 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20787 $result->{systemException} = $@;
20788 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20789 $result->{notFoundException} = $@;
20790 }
20791 $output->writeMessageBegin('getNoteContent', TMessageType::REPLY, $seqid);
20792 $result->write($output);
20793 $output->writeMessageEnd();
20794 $output->getTransport()->flush();
20795 }
20796  
20797 sub process_getNoteSearchText {
20798 my ($self, $seqid, $input, $output) = @_;
20799 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_args->new();
20800 $args->read($input);
20801 $input->readMessageEnd();
20802 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteSearchText_result->new();
20803 eval {
20804 $result->{success} = $self->{handler}->getNoteSearchText($args->authenticationToken, $args->guid, $args->noteOnly, $args->tokenizeForIndexing);
20805 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20806 $result->{userException} = $@;
20807 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20808 $result->{systemException} = $@;
20809 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20810 $result->{notFoundException} = $@;
20811 }
20812 $output->writeMessageBegin('getNoteSearchText', TMessageType::REPLY, $seqid);
20813 $result->write($output);
20814 $output->writeMessageEnd();
20815 $output->getTransport()->flush();
20816 }
20817  
20818 sub process_getResourceSearchText {
20819 my ($self, $seqid, $input, $output) = @_;
20820 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_args->new();
20821 $args->read($input);
20822 $input->readMessageEnd();
20823 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceSearchText_result->new();
20824 eval {
20825 $result->{success} = $self->{handler}->getResourceSearchText($args->authenticationToken, $args->guid);
20826 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20827 $result->{userException} = $@;
20828 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20829 $result->{systemException} = $@;
20830 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20831 $result->{notFoundException} = $@;
20832 }
20833 $output->writeMessageBegin('getResourceSearchText', TMessageType::REPLY, $seqid);
20834 $result->write($output);
20835 $output->writeMessageEnd();
20836 $output->getTransport()->flush();
20837 }
20838  
20839 sub process_getNoteTagNames {
20840 my ($self, $seqid, $input, $output) = @_;
20841 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_args->new();
20842 $args->read($input);
20843 $input->readMessageEnd();
20844 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteTagNames_result->new();
20845 eval {
20846 $result->{success} = $self->{handler}->getNoteTagNames($args->authenticationToken, $args->guid);
20847 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20848 $result->{userException} = $@;
20849 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20850 $result->{systemException} = $@;
20851 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20852 $result->{notFoundException} = $@;
20853 }
20854 $output->writeMessageBegin('getNoteTagNames', TMessageType::REPLY, $seqid);
20855 $result->write($output);
20856 $output->writeMessageEnd();
20857 $output->getTransport()->flush();
20858 }
20859  
20860 sub process_createNote {
20861 my ($self, $seqid, $input, $output) = @_;
20862 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createNote_args->new();
20863 $args->read($input);
20864 $input->readMessageEnd();
20865 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createNote_result->new();
20866 eval {
20867 $result->{success} = $self->{handler}->createNote($args->authenticationToken, $args->note);
20868 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20869 $result->{userException} = $@;
20870 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20871 $result->{systemException} = $@;
20872 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20873 $result->{notFoundException} = $@;
20874 }
20875 $output->writeMessageBegin('createNote', TMessageType::REPLY, $seqid);
20876 $result->write($output);
20877 $output->writeMessageEnd();
20878 $output->getTransport()->flush();
20879 }
20880  
20881 sub process_updateNote {
20882 my ($self, $seqid, $input, $output) = @_;
20883 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_args->new();
20884 $args->read($input);
20885 $input->readMessageEnd();
20886 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateNote_result->new();
20887 eval {
20888 $result->{success} = $self->{handler}->updateNote($args->authenticationToken, $args->note);
20889 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20890 $result->{userException} = $@;
20891 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20892 $result->{systemException} = $@;
20893 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20894 $result->{notFoundException} = $@;
20895 }
20896 $output->writeMessageBegin('updateNote', TMessageType::REPLY, $seqid);
20897 $result->write($output);
20898 $output->writeMessageEnd();
20899 $output->getTransport()->flush();
20900 }
20901  
20902 sub process_deleteNote {
20903 my ($self, $seqid, $input, $output) = @_;
20904 my $args = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_args->new();
20905 $args->read($input);
20906 $input->readMessageEnd();
20907 my $result = Net::Evernote::EDAMNoteStore::NoteStore_deleteNote_result->new();
20908 eval {
20909 $result->{success} = $self->{handler}->deleteNote($args->authenticationToken, $args->guid);
20910 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20911 $result->{userException} = $@;
20912 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20913 $result->{systemException} = $@;
20914 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20915 $result->{notFoundException} = $@;
20916 }
20917 $output->writeMessageBegin('deleteNote', TMessageType::REPLY, $seqid);
20918 $result->write($output);
20919 $output->writeMessageEnd();
20920 $output->getTransport()->flush();
20921 }
20922  
20923 sub process_expungeNote {
20924 my ($self, $seqid, $input, $output) = @_;
20925 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_args->new();
20926 $args->read($input);
20927 $input->readMessageEnd();
20928 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNote_result->new();
20929 eval {
20930 $result->{success} = $self->{handler}->expungeNote($args->authenticationToken, $args->guid);
20931 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20932 $result->{userException} = $@;
20933 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20934 $result->{systemException} = $@;
20935 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20936 $result->{notFoundException} = $@;
20937 }
20938 $output->writeMessageBegin('expungeNote', TMessageType::REPLY, $seqid);
20939 $result->write($output);
20940 $output->writeMessageEnd();
20941 $output->getTransport()->flush();
20942 }
20943  
20944 sub process_expungeNotes {
20945 my ($self, $seqid, $input, $output) = @_;
20946 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_args->new();
20947 $args->read($input);
20948 $input->readMessageEnd();
20949 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeNotes_result->new();
20950 eval {
20951 $result->{success} = $self->{handler}->expungeNotes($args->authenticationToken, $args->noteGuids);
20952 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20953 $result->{userException} = $@;
20954 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20955 $result->{systemException} = $@;
20956 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20957 $result->{notFoundException} = $@;
20958 }
20959 $output->writeMessageBegin('expungeNotes', TMessageType::REPLY, $seqid);
20960 $result->write($output);
20961 $output->writeMessageEnd();
20962 $output->getTransport()->flush();
20963 }
20964  
20965 sub process_expungeInactiveNotes {
20966 my ($self, $seqid, $input, $output) = @_;
20967 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_args->new();
20968 $args->read($input);
20969 $input->readMessageEnd();
20970 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeInactiveNotes_result->new();
20971 eval {
20972 $result->{success} = $self->{handler}->expungeInactiveNotes($args->authenticationToken);
20973 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20974 $result->{userException} = $@;
20975 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20976 $result->{systemException} = $@;
20977 }
20978 $output->writeMessageBegin('expungeInactiveNotes', TMessageType::REPLY, $seqid);
20979 $result->write($output);
20980 $output->writeMessageEnd();
20981 $output->getTransport()->flush();
20982 }
20983  
20984 sub process_copyNote {
20985 my ($self, $seqid, $input, $output) = @_;
20986 my $args = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_args->new();
20987 $args->read($input);
20988 $input->readMessageEnd();
20989 my $result = Net::Evernote::EDAMNoteStore::NoteStore_copyNote_result->new();
20990 eval {
20991 $result->{success} = $self->{handler}->copyNote($args->authenticationToken, $args->noteGuid, $args->toNotebookGuid);
20992 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
20993 $result->{userException} = $@;
20994 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
20995 $result->{systemException} = $@;
20996 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
20997 $result->{notFoundException} = $@;
20998 }
20999 $output->writeMessageBegin('copyNote', TMessageType::REPLY, $seqid);
21000 $result->write($output);
21001 $output->writeMessageEnd();
21002 $output->getTransport()->flush();
21003 }
21004  
21005 sub process_listNoteVersions {
21006 my ($self, $seqid, $input, $output) = @_;
21007 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_args->new();
21008 $args->read($input);
21009 $input->readMessageEnd();
21010 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listNoteVersions_result->new();
21011 eval {
21012 $result->{success} = $self->{handler}->listNoteVersions($args->authenticationToken, $args->noteGuid);
21013 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21014 $result->{userException} = $@;
21015 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21016 $result->{systemException} = $@;
21017 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21018 $result->{notFoundException} = $@;
21019 }
21020 $output->writeMessageBegin('listNoteVersions', TMessageType::REPLY, $seqid);
21021 $result->write($output);
21022 $output->writeMessageEnd();
21023 $output->getTransport()->flush();
21024 }
21025  
21026 sub process_getNoteVersion {
21027 my ($self, $seqid, $input, $output) = @_;
21028 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_args->new();
21029 $args->read($input);
21030 $input->readMessageEnd();
21031 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getNoteVersion_result->new();
21032 eval {
21033 $result->{success} = $self->{handler}->getNoteVersion($args->authenticationToken, $args->noteGuid, $args->updateSequenceNum, $args->withResourcesData, $args->withResourcesRecognition, $args->withResourcesAlternateData);
21034 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21035 $result->{userException} = $@;
21036 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21037 $result->{systemException} = $@;
21038 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21039 $result->{notFoundException} = $@;
21040 }
21041 $output->writeMessageBegin('getNoteVersion', TMessageType::REPLY, $seqid);
21042 $result->write($output);
21043 $output->writeMessageEnd();
21044 $output->getTransport()->flush();
21045 }
21046  
21047 sub process_getResource {
21048 my ($self, $seqid, $input, $output) = @_;
21049 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResource_args->new();
21050 $args->read($input);
21051 $input->readMessageEnd();
21052 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResource_result->new();
21053 eval {
21054 $result->{success} = $self->{handler}->getResource($args->authenticationToken, $args->guid, $args->withData, $args->withRecognition, $args->withAttributes, $args->withAlternateData);
21055 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21056 $result->{userException} = $@;
21057 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21058 $result->{systemException} = $@;
21059 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21060 $result->{notFoundException} = $@;
21061 }
21062 $output->writeMessageBegin('getResource', TMessageType::REPLY, $seqid);
21063 $result->write($output);
21064 $output->writeMessageEnd();
21065 $output->getTransport()->flush();
21066 }
21067  
21068 sub process_getResourceApplicationData {
21069 my ($self, $seqid, $input, $output) = @_;
21070 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_args->new();
21071 $args->read($input);
21072 $input->readMessageEnd();
21073 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationData_result->new();
21074 eval {
21075 $result->{success} = $self->{handler}->getResourceApplicationData($args->authenticationToken, $args->guid);
21076 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21077 $result->{userException} = $@;
21078 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21079 $result->{systemException} = $@;
21080 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21081 $result->{notFoundException} = $@;
21082 }
21083 $output->writeMessageBegin('getResourceApplicationData', TMessageType::REPLY, $seqid);
21084 $result->write($output);
21085 $output->writeMessageEnd();
21086 $output->getTransport()->flush();
21087 }
21088  
21089 sub process_getResourceApplicationDataEntry {
21090 my ($self, $seqid, $input, $output) = @_;
21091 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_args->new();
21092 $args->read($input);
21093 $input->readMessageEnd();
21094 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceApplicationDataEntry_result->new();
21095 eval {
21096 $result->{success} = $self->{handler}->getResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
21097 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21098 $result->{userException} = $@;
21099 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21100 $result->{systemException} = $@;
21101 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21102 $result->{notFoundException} = $@;
21103 }
21104 $output->writeMessageBegin('getResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
21105 $result->write($output);
21106 $output->writeMessageEnd();
21107 $output->getTransport()->flush();
21108 }
21109  
21110 sub process_setResourceApplicationDataEntry {
21111 my ($self, $seqid, $input, $output) = @_;
21112 my $args = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_args->new();
21113 $args->read($input);
21114 $input->readMessageEnd();
21115 my $result = Net::Evernote::EDAMNoteStore::NoteStore_setResourceApplicationDataEntry_result->new();
21116 eval {
21117 $result->{success} = $self->{handler}->setResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key, $args->value);
21118 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21119 $result->{userException} = $@;
21120 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21121 $result->{systemException} = $@;
21122 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21123 $result->{notFoundException} = $@;
21124 }
21125 $output->writeMessageBegin('setResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
21126 $result->write($output);
21127 $output->writeMessageEnd();
21128 $output->getTransport()->flush();
21129 }
21130  
21131 sub process_unsetResourceApplicationDataEntry {
21132 my ($self, $seqid, $input, $output) = @_;
21133 my $args = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_args->new();
21134 $args->read($input);
21135 $input->readMessageEnd();
21136 my $result = Net::Evernote::EDAMNoteStore::NoteStore_unsetResourceApplicationDataEntry_result->new();
21137 eval {
21138 $result->{success} = $self->{handler}->unsetResourceApplicationDataEntry($args->authenticationToken, $args->guid, $args->key);
21139 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21140 $result->{userException} = $@;
21141 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21142 $result->{systemException} = $@;
21143 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21144 $result->{notFoundException} = $@;
21145 }
21146 $output->writeMessageBegin('unsetResourceApplicationDataEntry', TMessageType::REPLY, $seqid);
21147 $result->write($output);
21148 $output->writeMessageEnd();
21149 $output->getTransport()->flush();
21150 }
21151  
21152 sub process_updateResource {
21153 my ($self, $seqid, $input, $output) = @_;
21154 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_args->new();
21155 $args->read($input);
21156 $input->readMessageEnd();
21157 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateResource_result->new();
21158 eval {
21159 $result->{success} = $self->{handler}->updateResource($args->authenticationToken, $args->resource);
21160 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21161 $result->{userException} = $@;
21162 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21163 $result->{systemException} = $@;
21164 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21165 $result->{notFoundException} = $@;
21166 }
21167 $output->writeMessageBegin('updateResource', TMessageType::REPLY, $seqid);
21168 $result->write($output);
21169 $output->writeMessageEnd();
21170 $output->getTransport()->flush();
21171 }
21172  
21173 sub process_getResourceData {
21174 my ($self, $seqid, $input, $output) = @_;
21175 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_args->new();
21176 $args->read($input);
21177 $input->readMessageEnd();
21178 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceData_result->new();
21179 eval {
21180 $result->{success} = $self->{handler}->getResourceData($args->authenticationToken, $args->guid);
21181 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21182 $result->{userException} = $@;
21183 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21184 $result->{systemException} = $@;
21185 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21186 $result->{notFoundException} = $@;
21187 }
21188 $output->writeMessageBegin('getResourceData', TMessageType::REPLY, $seqid);
21189 $result->write($output);
21190 $output->writeMessageEnd();
21191 $output->getTransport()->flush();
21192 }
21193  
21194 sub process_getResourceByHash {
21195 my ($self, $seqid, $input, $output) = @_;
21196 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_args->new();
21197 $args->read($input);
21198 $input->readMessageEnd();
21199 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceByHash_result->new();
21200 eval {
21201 $result->{success} = $self->{handler}->getResourceByHash($args->authenticationToken, $args->noteGuid, $args->contentHash, $args->withData, $args->withRecognition, $args->withAlternateData);
21202 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21203 $result->{userException} = $@;
21204 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21205 $result->{systemException} = $@;
21206 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21207 $result->{notFoundException} = $@;
21208 }
21209 $output->writeMessageBegin('getResourceByHash', TMessageType::REPLY, $seqid);
21210 $result->write($output);
21211 $output->writeMessageEnd();
21212 $output->getTransport()->flush();
21213 }
21214  
21215 sub process_getResourceRecognition {
21216 my ($self, $seqid, $input, $output) = @_;
21217 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_args->new();
21218 $args->read($input);
21219 $input->readMessageEnd();
21220 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceRecognition_result->new();
21221 eval {
21222 $result->{success} = $self->{handler}->getResourceRecognition($args->authenticationToken, $args->guid);
21223 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21224 $result->{userException} = $@;
21225 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21226 $result->{systemException} = $@;
21227 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21228 $result->{notFoundException} = $@;
21229 }
21230 $output->writeMessageBegin('getResourceRecognition', TMessageType::REPLY, $seqid);
21231 $result->write($output);
21232 $output->writeMessageEnd();
21233 $output->getTransport()->flush();
21234 }
21235  
21236 sub process_getResourceAlternateData {
21237 my ($self, $seqid, $input, $output) = @_;
21238 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_args->new();
21239 $args->read($input);
21240 $input->readMessageEnd();
21241 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAlternateData_result->new();
21242 eval {
21243 $result->{success} = $self->{handler}->getResourceAlternateData($args->authenticationToken, $args->guid);
21244 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21245 $result->{userException} = $@;
21246 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21247 $result->{systemException} = $@;
21248 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21249 $result->{notFoundException} = $@;
21250 }
21251 $output->writeMessageBegin('getResourceAlternateData', TMessageType::REPLY, $seqid);
21252 $result->write($output);
21253 $output->writeMessageEnd();
21254 $output->getTransport()->flush();
21255 }
21256  
21257 sub process_getResourceAttributes {
21258 my ($self, $seqid, $input, $output) = @_;
21259 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_args->new();
21260 $args->read($input);
21261 $input->readMessageEnd();
21262 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getResourceAttributes_result->new();
21263 eval {
21264 $result->{success} = $self->{handler}->getResourceAttributes($args->authenticationToken, $args->guid);
21265 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21266 $result->{userException} = $@;
21267 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21268 $result->{systemException} = $@;
21269 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21270 $result->{notFoundException} = $@;
21271 }
21272 $output->writeMessageBegin('getResourceAttributes', TMessageType::REPLY, $seqid);
21273 $result->write($output);
21274 $output->writeMessageEnd();
21275 $output->getTransport()->flush();
21276 }
21277  
21278 sub process_getAccountSize {
21279 my ($self, $seqid, $input, $output) = @_;
21280 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_args->new();
21281 $args->read($input);
21282 $input->readMessageEnd();
21283 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAccountSize_result->new();
21284 eval {
21285 $result->{success} = $self->{handler}->getAccountSize($args->authenticationToken);
21286 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21287 $result->{userException} = $@;
21288 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21289 $result->{systemException} = $@;
21290 }
21291 $output->writeMessageBegin('getAccountSize', TMessageType::REPLY, $seqid);
21292 $result->write($output);
21293 $output->writeMessageEnd();
21294 $output->getTransport()->flush();
21295 }
21296  
21297 sub process_getAds {
21298 my ($self, $seqid, $input, $output) = @_;
21299 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getAds_args->new();
21300 $args->read($input);
21301 $input->readMessageEnd();
21302 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getAds_result->new();
21303 eval {
21304 $result->{success} = $self->{handler}->getAds($args->authenticationToken, $args->adParameters);
21305 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21306 $result->{userException} = $@;
21307 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21308 $result->{systemException} = $@;
21309 }
21310 $output->writeMessageBegin('getAds', TMessageType::REPLY, $seqid);
21311 $result->write($output);
21312 $output->writeMessageEnd();
21313 $output->getTransport()->flush();
21314 }
21315  
21316 sub process_getRandomAd {
21317 my ($self, $seqid, $input, $output) = @_;
21318 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_args->new();
21319 $args->read($input);
21320 $input->readMessageEnd();
21321 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getRandomAd_result->new();
21322 eval {
21323 $result->{success} = $self->{handler}->getRandomAd($args->authenticationToken, $args->adParameters);
21324 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21325 $result->{userException} = $@;
21326 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21327 $result->{systemException} = $@;
21328 }
21329 $output->writeMessageBegin('getRandomAd', TMessageType::REPLY, $seqid);
21330 $result->write($output);
21331 $output->writeMessageEnd();
21332 $output->getTransport()->flush();
21333 }
21334  
21335 sub process_getPublicNotebook {
21336 my ($self, $seqid, $input, $output) = @_;
21337 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_args->new();
21338 $args->read($input);
21339 $input->readMessageEnd();
21340 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getPublicNotebook_result->new();
21341 eval {
21342 $result->{success} = $self->{handler}->getPublicNotebook($args->userId, $args->publicUri);
21343 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21344 $result->{systemException} = $@;
21345 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21346 $result->{notFoundException} = $@;
21347 }
21348 $output->writeMessageBegin('getPublicNotebook', TMessageType::REPLY, $seqid);
21349 $result->write($output);
21350 $output->writeMessageEnd();
21351 $output->getTransport()->flush();
21352 }
21353  
21354 sub process_createSharedNotebook {
21355 my ($self, $seqid, $input, $output) = @_;
21356 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_args->new();
21357 $args->read($input);
21358 $input->readMessageEnd();
21359 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createSharedNotebook_result->new();
21360 eval {
21361 $result->{success} = $self->{handler}->createSharedNotebook($args->authenticationToken, $args->sharedNotebook);
21362 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21363 $result->{userException} = $@;
21364 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21365 $result->{notFoundException} = $@;
21366 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21367 $result->{systemException} = $@;
21368 }
21369 $output->writeMessageBegin('createSharedNotebook', TMessageType::REPLY, $seqid);
21370 $result->write($output);
21371 $output->writeMessageEnd();
21372 $output->getTransport()->flush();
21373 }
21374  
21375 sub process_sendMessageToSharedNotebookMembers {
21376 my ($self, $seqid, $input, $output) = @_;
21377 my $args = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_args->new();
21378 $args->read($input);
21379 $input->readMessageEnd();
21380 my $result = Net::Evernote::EDAMNoteStore::NoteStore_sendMessageToSharedNotebookMembers_result->new();
21381 eval {
21382 $result->{success} = $self->{handler}->sendMessageToSharedNotebookMembers($args->authenticationToken, $args->notebookGuid, $args->messageText, $args->recipients);
21383 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21384 $result->{userException} = $@;
21385 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21386 $result->{notFoundException} = $@;
21387 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21388 $result->{systemException} = $@;
21389 }
21390 $output->writeMessageBegin('sendMessageToSharedNotebookMembers', TMessageType::REPLY, $seqid);
21391 $result->write($output);
21392 $output->writeMessageEnd();
21393 $output->getTransport()->flush();
21394 }
21395  
21396 sub process_listSharedNotebooks {
21397 my ($self, $seqid, $input, $output) = @_;
21398 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_args->new();
21399 $args->read($input);
21400 $input->readMessageEnd();
21401 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listSharedNotebooks_result->new();
21402 eval {
21403 $result->{success} = $self->{handler}->listSharedNotebooks($args->authenticationToken);
21404 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21405 $result->{userException} = $@;
21406 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21407 $result->{notFoundException} = $@;
21408 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21409 $result->{systemException} = $@;
21410 }
21411 $output->writeMessageBegin('listSharedNotebooks', TMessageType::REPLY, $seqid);
21412 $result->write($output);
21413 $output->writeMessageEnd();
21414 $output->getTransport()->flush();
21415 }
21416  
21417 sub process_expungeSharedNotebooks {
21418 my ($self, $seqid, $input, $output) = @_;
21419 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_args->new();
21420 $args->read($input);
21421 $input->readMessageEnd();
21422 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeSharedNotebooks_result->new();
21423 eval {
21424 $result->{success} = $self->{handler}->expungeSharedNotebooks($args->authenticationToken, $args->sharedNotebookIds);
21425 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21426 $result->{userException} = $@;
21427 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21428 $result->{notFoundException} = $@;
21429 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21430 $result->{systemException} = $@;
21431 }
21432 $output->writeMessageBegin('expungeSharedNotebooks', TMessageType::REPLY, $seqid);
21433 $result->write($output);
21434 $output->writeMessageEnd();
21435 $output->getTransport()->flush();
21436 }
21437  
21438 sub process_createLinkedNotebook {
21439 my ($self, $seqid, $input, $output) = @_;
21440 my $args = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_args->new();
21441 $args->read($input);
21442 $input->readMessageEnd();
21443 my $result = Net::Evernote::EDAMNoteStore::NoteStore_createLinkedNotebook_result->new();
21444 eval {
21445 $result->{success} = $self->{handler}->createLinkedNotebook($args->authenticationToken, $args->linkedNotebook);
21446 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21447 $result->{userException} = $@;
21448 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21449 $result->{notFoundException} = $@;
21450 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21451 $result->{systemException} = $@;
21452 }
21453 $output->writeMessageBegin('createLinkedNotebook', TMessageType::REPLY, $seqid);
21454 $result->write($output);
21455 $output->writeMessageEnd();
21456 $output->getTransport()->flush();
21457 }
21458  
21459 sub process_updateLinkedNotebook {
21460 my ($self, $seqid, $input, $output) = @_;
21461 my $args = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_args->new();
21462 $args->read($input);
21463 $input->readMessageEnd();
21464 my $result = Net::Evernote::EDAMNoteStore::NoteStore_updateLinkedNotebook_result->new();
21465 eval {
21466 $result->{success} = $self->{handler}->updateLinkedNotebook($args->authenticationToken, $args->linkedNotebook);
21467 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21468 $result->{userException} = $@;
21469 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21470 $result->{notFoundException} = $@;
21471 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21472 $result->{systemException} = $@;
21473 }
21474 $output->writeMessageBegin('updateLinkedNotebook', TMessageType::REPLY, $seqid);
21475 $result->write($output);
21476 $output->writeMessageEnd();
21477 $output->getTransport()->flush();
21478 }
21479  
21480 sub process_listLinkedNotebooks {
21481 my ($self, $seqid, $input, $output) = @_;
21482 my $args = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_args->new();
21483 $args->read($input);
21484 $input->readMessageEnd();
21485 my $result = Net::Evernote::EDAMNoteStore::NoteStore_listLinkedNotebooks_result->new();
21486 eval {
21487 $result->{success} = $self->{handler}->listLinkedNotebooks($args->authenticationToken);
21488 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21489 $result->{userException} = $@;
21490 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21491 $result->{notFoundException} = $@;
21492 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21493 $result->{systemException} = $@;
21494 }
21495 $output->writeMessageBegin('listLinkedNotebooks', TMessageType::REPLY, $seqid);
21496 $result->write($output);
21497 $output->writeMessageEnd();
21498 $output->getTransport()->flush();
21499 }
21500  
21501 sub process_expungeLinkedNotebook {
21502 my ($self, $seqid, $input, $output) = @_;
21503 my $args = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_args->new();
21504 $args->read($input);
21505 $input->readMessageEnd();
21506 my $result = Net::Evernote::EDAMNoteStore::NoteStore_expungeLinkedNotebook_result->new();
21507 eval {
21508 $result->{success} = $self->{handler}->expungeLinkedNotebook($args->authenticationToken, $args->guid);
21509 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21510 $result->{userException} = $@;
21511 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21512 $result->{notFoundException} = $@;
21513 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21514 $result->{systemException} = $@;
21515 }
21516 $output->writeMessageBegin('expungeLinkedNotebook', TMessageType::REPLY, $seqid);
21517 $result->write($output);
21518 $output->writeMessageEnd();
21519 $output->getTransport()->flush();
21520 }
21521  
21522 sub process_authenticateToSharedNotebook {
21523 my ($self, $seqid, $input, $output) = @_;
21524 my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_args->new();
21525 $args->read($input);
21526 $input->readMessageEnd();
21527 my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNotebook_result->new();
21528 eval {
21529 $result->{success} = $self->{handler}->authenticateToSharedNotebook($args->shareKey, $args->authenticationToken);
21530 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21531 $result->{userException} = $@;
21532 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21533 $result->{notFoundException} = $@;
21534 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21535 $result->{systemException} = $@;
21536 }
21537 $output->writeMessageBegin('authenticateToSharedNotebook', TMessageType::REPLY, $seqid);
21538 $result->write($output);
21539 $output->writeMessageEnd();
21540 $output->getTransport()->flush();
21541 }
21542  
21543 sub process_getSharedNotebookByAuth {
21544 my ($self, $seqid, $input, $output) = @_;
21545 my $args = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_args->new();
21546 $args->read($input);
21547 $input->readMessageEnd();
21548 my $result = Net::Evernote::EDAMNoteStore::NoteStore_getSharedNotebookByAuth_result->new();
21549 eval {
21550 $result->{success} = $self->{handler}->getSharedNotebookByAuth($args->authenticationToken);
21551 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21552 $result->{userException} = $@;
21553 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21554 $result->{notFoundException} = $@;
21555 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21556 $result->{systemException} = $@;
21557 }
21558 $output->writeMessageBegin('getSharedNotebookByAuth', TMessageType::REPLY, $seqid);
21559 $result->write($output);
21560 $output->writeMessageEnd();
21561 $output->getTransport()->flush();
21562 }
21563  
21564 sub process_emailNote {
21565 my ($self, $seqid, $input, $output) = @_;
21566 my $args = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_args->new();
21567 $args->read($input);
21568 $input->readMessageEnd();
21569 my $result = Net::Evernote::EDAMNoteStore::NoteStore_emailNote_result->new();
21570 eval {
21571 $self->{handler}->emailNote($args->authenticationToken, $args->parameters);
21572 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21573 $result->{userException} = $@;
21574 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21575 $result->{notFoundException} = $@;
21576 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21577 $result->{systemException} = $@;
21578 }
21579 $output->writeMessageBegin('emailNote', TMessageType::REPLY, $seqid);
21580 $result->write($output);
21581 $output->writeMessageEnd();
21582 $output->getTransport()->flush();
21583 }
21584  
21585 sub process_shareNote {
21586 my ($self, $seqid, $input, $output) = @_;
21587 my $args = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_args->new();
21588 $args->read($input);
21589 $input->readMessageEnd();
21590 my $result = Net::Evernote::EDAMNoteStore::NoteStore_shareNote_result->new();
21591 eval {
21592 $result->{success} = $self->{handler}->shareNote($args->authenticationToken, $args->guid);
21593 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21594 $result->{userException} = $@;
21595 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21596 $result->{notFoundException} = $@;
21597 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21598 $result->{systemException} = $@;
21599 }
21600 $output->writeMessageBegin('shareNote', TMessageType::REPLY, $seqid);
21601 $result->write($output);
21602 $output->writeMessageEnd();
21603 $output->getTransport()->flush();
21604 }
21605  
21606 sub process_stopSharingNote {
21607 my ($self, $seqid, $input, $output) = @_;
21608 my $args = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_args->new();
21609 $args->read($input);
21610 $input->readMessageEnd();
21611 my $result = Net::Evernote::EDAMNoteStore::NoteStore_stopSharingNote_result->new();
21612 eval {
21613 $self->{handler}->stopSharingNote($args->authenticationToken, $args->guid);
21614 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21615 $result->{userException} = $@;
21616 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21617 $result->{notFoundException} = $@;
21618 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21619 $result->{systemException} = $@;
21620 }
21621 $output->writeMessageBegin('stopSharingNote', TMessageType::REPLY, $seqid);
21622 $result->write($output);
21623 $output->writeMessageEnd();
21624 $output->getTransport()->flush();
21625 }
21626  
21627 sub process_authenticateToSharedNote {
21628 my ($self, $seqid, $input, $output) = @_;
21629 my $args = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_args->new();
21630 $args->read($input);
21631 $input->readMessageEnd();
21632 my $result = Net::Evernote::EDAMNoteStore::NoteStore_authenticateToSharedNote_result->new();
21633 eval {
21634 $result->{success} = $self->{handler}->authenticateToSharedNote($args->guid, $args->noteKey);
21635 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMUserException') ){
21636 $result->{userException} = $@;
21637 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMNotFoundException') ){
21638 $result->{notFoundException} = $@;
21639 }; if( UNIVERSAL::isa($@,'Net::Evernote::EDAMErrors::Net::Evernote::EDAMSystemException') ){
21640 $result->{systemException} = $@;
21641 }
21642 $output->writeMessageBegin('authenticateToSharedNote', TMessageType::REPLY, $seqid);
21643 $result->write($output);
21644 $output->writeMessageEnd();
21645 $output->getTransport()->flush();
21646 }
21647  
21648 1;