1
// Copyright 2008 The Closure Library Authors. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS-IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
// All other code copyright its respective owners(s).
15

16
/**
17
 * @fileoverview Generated Protocol Buffer code for file
18
 * closure/goog/proto2/test.proto.
19
 */
20

21
goog.provide('proto2.TestAllTypes');
22
goog.provide('proto2.TestAllTypes.NestedEnum');
23
goog.provide('proto2.TestAllTypes.NestedMessage');
24
goog.provide('proto2.TestAllTypes.OptionalGroup');
25
goog.provide('proto2.TestAllTypes.RepeatedGroup');
26
goog.provide('proto2.TestDefaultChild');
27
goog.provide('proto2.TestDefaultParent');
28
goog.setTestOnly('proto2.TestAllTypes');
29

30
goog.require('goog.proto2.Message');
31

32

33

34
/**
35
 * Message TestAllTypes.
36
 * @constructor
37
 * @extends {goog.proto2.Message}
38
 * @final
39
 */
40
proto2.TestAllTypes = function() {
41
  goog.proto2.Message.call(this);
42
};
43
goog.inherits(proto2.TestAllTypes, goog.proto2.Message);
44

45

46
/**
47
 * Descriptor for this message, deserialized lazily in getDescriptor().
48
 * @private {?goog.proto2.Descriptor}
49
 */
50
proto2.TestAllTypes.descriptor_ = null;
51

52

53
/**
54
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
55
 * @return {!proto2.TestAllTypes} The cloned message.
56
 * @override
57
 */
58
proto2.TestAllTypes.prototype.clone;
59

60

61
/**
62
 * Gets the value of the optional_int32 field.
63
 * @return {?number} The value.
64
 */
65
proto2.TestAllTypes.prototype.getOptionalInt32 = function() {
66
  return /** @type {?number} */ (this.get$Value(1));
67
};
68

69

70
/**
71
 * Gets the value of the optional_int32 field or the default value if not set.
72
 * @return {number} The value.
73
 */
74
proto2.TestAllTypes.prototype.getOptionalInt32OrDefault = function() {
75
  return /** @type {number} */ (this.get$ValueOrDefault(1));
76
};
77

78

79
/**
80
 * Sets the value of the optional_int32 field.
81
 * @param {number} value The value.
82
 */
83
proto2.TestAllTypes.prototype.setOptionalInt32 = function(value) {
84
  this.set$Value(1, value);
85
};
86

87

88
/**
89
 * @return {boolean} Whether the optional_int32 field has a value.
90
 */
91
proto2.TestAllTypes.prototype.hasOptionalInt32 = function() {
92
  return this.has$Value(1);
93
};
94

95

96
/**
97
 * @return {number} The number of values in the optional_int32 field.
98
 */
99
proto2.TestAllTypes.prototype.optionalInt32Count = function() {
100
  return this.count$Values(1);
101
};
102

103

104
/**
105
 * Clears the values in the optional_int32 field.
106
 */
107
proto2.TestAllTypes.prototype.clearOptionalInt32 = function() {
108
  this.clear$Field(1);
109
};
110

111

112
/**
113
 * Gets the value of the optional_int64 field.
114
 * @return {?string} The value.
115
 */
116
proto2.TestAllTypes.prototype.getOptionalInt64 = function() {
117
  return /** @type {?string} */ (this.get$Value(2));
118
};
119

120

121
/**
122
 * Gets the value of the optional_int64 field or the default value if not set.
123
 * @return {string} The value.
124
 */
125
proto2.TestAllTypes.prototype.getOptionalInt64OrDefault = function() {
126
  return /** @type {string} */ (this.get$ValueOrDefault(2));
127
};
128

129

130
/**
131
 * Sets the value of the optional_int64 field.
132
 * @param {string} value The value.
133
 */
134
proto2.TestAllTypes.prototype.setOptionalInt64 = function(value) {
135
  this.set$Value(2, value);
136
};
137

138

139
/**
140
 * @return {boolean} Whether the optional_int64 field has a value.
141
 */
142
proto2.TestAllTypes.prototype.hasOptionalInt64 = function() {
143
  return this.has$Value(2);
144
};
145

146

147
/**
148
 * @return {number} The number of values in the optional_int64 field.
149
 */
150
proto2.TestAllTypes.prototype.optionalInt64Count = function() {
151
  return this.count$Values(2);
152
};
153

154

155
/**
156
 * Clears the values in the optional_int64 field.
157
 */
158
proto2.TestAllTypes.prototype.clearOptionalInt64 = function() {
159
  this.clear$Field(2);
160
};
161

162

163
/**
164
 * Gets the value of the optional_uint32 field.
165
 * @return {?number} The value.
166
 */
167
proto2.TestAllTypes.prototype.getOptionalUint32 = function() {
168
  return /** @type {?number} */ (this.get$Value(3));
169
};
170

171

172
/**
173
 * Gets the value of the optional_uint32 field or the default value if not set.
174
 * @return {number} The value.
175
 */
176
proto2.TestAllTypes.prototype.getOptionalUint32OrDefault = function() {
177
  return /** @type {number} */ (this.get$ValueOrDefault(3));
178
};
179

180

181
/**
182
 * Sets the value of the optional_uint32 field.
183
 * @param {number} value The value.
184
 */
185
proto2.TestAllTypes.prototype.setOptionalUint32 = function(value) {
186
  this.set$Value(3, value);
187
};
188

189

190
/**
191
 * @return {boolean} Whether the optional_uint32 field has a value.
192
 */
193
proto2.TestAllTypes.prototype.hasOptionalUint32 = function() {
194
  return this.has$Value(3);
195
};
196

197

198
/**
199
 * @return {number} The number of values in the optional_uint32 field.
200
 */
201
proto2.TestAllTypes.prototype.optionalUint32Count = function() {
202
  return this.count$Values(3);
203
};
204

205

206
/**
207
 * Clears the values in the optional_uint32 field.
208
 */
209
proto2.TestAllTypes.prototype.clearOptionalUint32 = function() {
210
  this.clear$Field(3);
211
};
212

213

214
/**
215
 * Gets the value of the optional_uint64 field.
216
 * @return {?string} The value.
217
 */
218
proto2.TestAllTypes.prototype.getOptionalUint64 = function() {
219
  return /** @type {?string} */ (this.get$Value(4));
220
};
221

222

223
/**
224
 * Gets the value of the optional_uint64 field or the default value if not set.
225
 * @return {string} The value.
226
 */
227
proto2.TestAllTypes.prototype.getOptionalUint64OrDefault = function() {
228
  return /** @type {string} */ (this.get$ValueOrDefault(4));
229
};
230

231

232
/**
233
 * Sets the value of the optional_uint64 field.
234
 * @param {string} value The value.
235
 */
236
proto2.TestAllTypes.prototype.setOptionalUint64 = function(value) {
237
  this.set$Value(4, value);
238
};
239

240

241
/**
242
 * @return {boolean} Whether the optional_uint64 field has a value.
243
 */
244
proto2.TestAllTypes.prototype.hasOptionalUint64 = function() {
245
  return this.has$Value(4);
246
};
247

248

249
/**
250
 * @return {number} The number of values in the optional_uint64 field.
251
 */
252
proto2.TestAllTypes.prototype.optionalUint64Count = function() {
253
  return this.count$Values(4);
254
};
255

256

257
/**
258
 * Clears the values in the optional_uint64 field.
259
 */
260
proto2.TestAllTypes.prototype.clearOptionalUint64 = function() {
261
  this.clear$Field(4);
262
};
263

264

265
/**
266
 * Gets the value of the optional_sint32 field.
267
 * @return {?number} The value.
268
 */
269
proto2.TestAllTypes.prototype.getOptionalSint32 = function() {
270
  return /** @type {?number} */ (this.get$Value(5));
271
};
272

273

274
/**
275
 * Gets the value of the optional_sint32 field or the default value if not set.
276
 * @return {number} The value.
277
 */
278
proto2.TestAllTypes.prototype.getOptionalSint32OrDefault = function() {
279
  return /** @type {number} */ (this.get$ValueOrDefault(5));
280
};
281

282

283
/**
284
 * Sets the value of the optional_sint32 field.
285
 * @param {number} value The value.
286
 */
287
proto2.TestAllTypes.prototype.setOptionalSint32 = function(value) {
288
  this.set$Value(5, value);
289
};
290

291

292
/**
293
 * @return {boolean} Whether the optional_sint32 field has a value.
294
 */
295
proto2.TestAllTypes.prototype.hasOptionalSint32 = function() {
296
  return this.has$Value(5);
297
};
298

299

300
/**
301
 * @return {number} The number of values in the optional_sint32 field.
302
 */
303
proto2.TestAllTypes.prototype.optionalSint32Count = function() {
304
  return this.count$Values(5);
305
};
306

307

308
/**
309
 * Clears the values in the optional_sint32 field.
310
 */
311
proto2.TestAllTypes.prototype.clearOptionalSint32 = function() {
312
  this.clear$Field(5);
313
};
314

315

316
/**
317
 * Gets the value of the optional_sint64 field.
318
 * @return {?string} The value.
319
 */
320
proto2.TestAllTypes.prototype.getOptionalSint64 = function() {
321
  return /** @type {?string} */ (this.get$Value(6));
322
};
323

324

325
/**
326
 * Gets the value of the optional_sint64 field or the default value if not set.
327
 * @return {string} The value.
328
 */
329
proto2.TestAllTypes.prototype.getOptionalSint64OrDefault = function() {
330
  return /** @type {string} */ (this.get$ValueOrDefault(6));
331
};
332

333

334
/**
335
 * Sets the value of the optional_sint64 field.
336
 * @param {string} value The value.
337
 */
338
proto2.TestAllTypes.prototype.setOptionalSint64 = function(value) {
339
  this.set$Value(6, value);
340
};
341

342

343
/**
344
 * @return {boolean} Whether the optional_sint64 field has a value.
345
 */
346
proto2.TestAllTypes.prototype.hasOptionalSint64 = function() {
347
  return this.has$Value(6);
348
};
349

350

351
/**
352
 * @return {number} The number of values in the optional_sint64 field.
353
 */
354
proto2.TestAllTypes.prototype.optionalSint64Count = function() {
355
  return this.count$Values(6);
356
};
357

358

359
/**
360
 * Clears the values in the optional_sint64 field.
361
 */
362
proto2.TestAllTypes.prototype.clearOptionalSint64 = function() {
363
  this.clear$Field(6);
364
};
365

366

367
/**
368
 * Gets the value of the optional_fixed32 field.
369
 * @return {?number} The value.
370
 */
371
proto2.TestAllTypes.prototype.getOptionalFixed32 = function() {
372
  return /** @type {?number} */ (this.get$Value(7));
373
};
374

375

376
/**
377
 * Gets the value of the optional_fixed32 field or the default value if not set.
378
 * @return {number} The value.
379
 */
380
proto2.TestAllTypes.prototype.getOptionalFixed32OrDefault = function() {
381
  return /** @type {number} */ (this.get$ValueOrDefault(7));
382
};
383

384

385
/**
386
 * Sets the value of the optional_fixed32 field.
387
 * @param {number} value The value.
388
 */
389
proto2.TestAllTypes.prototype.setOptionalFixed32 = function(value) {
390
  this.set$Value(7, value);
391
};
392

393

394
/**
395
 * @return {boolean} Whether the optional_fixed32 field has a value.
396
 */
397
proto2.TestAllTypes.prototype.hasOptionalFixed32 = function() {
398
  return this.has$Value(7);
399
};
400

401

402
/**
403
 * @return {number} The number of values in the optional_fixed32 field.
404
 */
405
proto2.TestAllTypes.prototype.optionalFixed32Count = function() {
406
  return this.count$Values(7);
407
};
408

409

410
/**
411
 * Clears the values in the optional_fixed32 field.
412
 */
413
proto2.TestAllTypes.prototype.clearOptionalFixed32 = function() {
414
  this.clear$Field(7);
415
};
416

417

418
/**
419
 * Gets the value of the optional_fixed64 field.
420
 * @return {?string} The value.
421
 */
422
proto2.TestAllTypes.prototype.getOptionalFixed64 = function() {
423
  return /** @type {?string} */ (this.get$Value(8));
424
};
425

426

427
/**
428
 * Gets the value of the optional_fixed64 field or the default value if not set.
429
 * @return {string} The value.
430
 */
431
proto2.TestAllTypes.prototype.getOptionalFixed64OrDefault = function() {
432
  return /** @type {string} */ (this.get$ValueOrDefault(8));
433
};
434

435

436
/**
437
 * Sets the value of the optional_fixed64 field.
438
 * @param {string} value The value.
439
 */
440
proto2.TestAllTypes.prototype.setOptionalFixed64 = function(value) {
441
  this.set$Value(8, value);
442
};
443

444

445
/**
446
 * @return {boolean} Whether the optional_fixed64 field has a value.
447
 */
448
proto2.TestAllTypes.prototype.hasOptionalFixed64 = function() {
449
  return this.has$Value(8);
450
};
451

452

453
/**
454
 * @return {number} The number of values in the optional_fixed64 field.
455
 */
456
proto2.TestAllTypes.prototype.optionalFixed64Count = function() {
457
  return this.count$Values(8);
458
};
459

460

461
/**
462
 * Clears the values in the optional_fixed64 field.
463
 */
464
proto2.TestAllTypes.prototype.clearOptionalFixed64 = function() {
465
  this.clear$Field(8);
466
};
467

468

469
/**
470
 * Gets the value of the optional_sfixed32 field.
471
 * @return {?number} The value.
472
 */
473
proto2.TestAllTypes.prototype.getOptionalSfixed32 = function() {
474
  return /** @type {?number} */ (this.get$Value(9));
475
};
476

477

478
/**
479
 * Gets the value of the optional_sfixed32 field or the default value if not set.
480
 * @return {number} The value.
481
 */
482
proto2.TestAllTypes.prototype.getOptionalSfixed32OrDefault = function() {
483
  return /** @type {number} */ (this.get$ValueOrDefault(9));
484
};
485

486

487
/**
488
 * Sets the value of the optional_sfixed32 field.
489
 * @param {number} value The value.
490
 */
491
proto2.TestAllTypes.prototype.setOptionalSfixed32 = function(value) {
492
  this.set$Value(9, value);
493
};
494

495

496
/**
497
 * @return {boolean} Whether the optional_sfixed32 field has a value.
498
 */
499
proto2.TestAllTypes.prototype.hasOptionalSfixed32 = function() {
500
  return this.has$Value(9);
501
};
502

503

504
/**
505
 * @return {number} The number of values in the optional_sfixed32 field.
506
 */
507
proto2.TestAllTypes.prototype.optionalSfixed32Count = function() {
508
  return this.count$Values(9);
509
};
510

511

512
/**
513
 * Clears the values in the optional_sfixed32 field.
514
 */
515
proto2.TestAllTypes.prototype.clearOptionalSfixed32 = function() {
516
  this.clear$Field(9);
517
};
518

519

520
/**
521
 * Gets the value of the optional_sfixed64 field.
522
 * @return {?string} The value.
523
 */
524
proto2.TestAllTypes.prototype.getOptionalSfixed64 = function() {
525
  return /** @type {?string} */ (this.get$Value(10));
526
};
527

528

529
/**
530
 * Gets the value of the optional_sfixed64 field or the default value if not set.
531
 * @return {string} The value.
532
 */
533
proto2.TestAllTypes.prototype.getOptionalSfixed64OrDefault = function() {
534
  return /** @type {string} */ (this.get$ValueOrDefault(10));
535
};
536

537

538
/**
539
 * Sets the value of the optional_sfixed64 field.
540
 * @param {string} value The value.
541
 */
542
proto2.TestAllTypes.prototype.setOptionalSfixed64 = function(value) {
543
  this.set$Value(10, value);
544
};
545

546

547
/**
548
 * @return {boolean} Whether the optional_sfixed64 field has a value.
549
 */
550
proto2.TestAllTypes.prototype.hasOptionalSfixed64 = function() {
551
  return this.has$Value(10);
552
};
553

554

555
/**
556
 * @return {number} The number of values in the optional_sfixed64 field.
557
 */
558
proto2.TestAllTypes.prototype.optionalSfixed64Count = function() {
559
  return this.count$Values(10);
560
};
561

562

563
/**
564
 * Clears the values in the optional_sfixed64 field.
565
 */
566
proto2.TestAllTypes.prototype.clearOptionalSfixed64 = function() {
567
  this.clear$Field(10);
568
};
569

570

571
/**
572
 * Gets the value of the optional_float field.
573
 * @return {?number} The value.
574
 */
575
proto2.TestAllTypes.prototype.getOptionalFloat = function() {
576
  return /** @type {?number} */ (this.get$Value(11));
577
};
578

579

580
/**
581
 * Gets the value of the optional_float field or the default value if not set.
582
 * @return {number} The value.
583
 */
584
proto2.TestAllTypes.prototype.getOptionalFloatOrDefault = function() {
585
  return /** @type {number} */ (this.get$ValueOrDefault(11));
586
};
587

588

589
/**
590
 * Sets the value of the optional_float field.
591
 * @param {number} value The value.
592
 */
593
proto2.TestAllTypes.prototype.setOptionalFloat = function(value) {
594
  this.set$Value(11, value);
595
};
596

597

598
/**
599
 * @return {boolean} Whether the optional_float field has a value.
600
 */
601
proto2.TestAllTypes.prototype.hasOptionalFloat = function() {
602
  return this.has$Value(11);
603
};
604

605

606
/**
607
 * @return {number} The number of values in the optional_float field.
608
 */
609
proto2.TestAllTypes.prototype.optionalFloatCount = function() {
610
  return this.count$Values(11);
611
};
612

613

614
/**
615
 * Clears the values in the optional_float field.
616
 */
617
proto2.TestAllTypes.prototype.clearOptionalFloat = function() {
618
  this.clear$Field(11);
619
};
620

621

622
/**
623
 * Gets the value of the optional_double field.
624
 * @return {?number} The value.
625
 */
626
proto2.TestAllTypes.prototype.getOptionalDouble = function() {
627
  return /** @type {?number} */ (this.get$Value(12));
628
};
629

630

631
/**
632
 * Gets the value of the optional_double field or the default value if not set.
633
 * @return {number} The value.
634
 */
635
proto2.TestAllTypes.prototype.getOptionalDoubleOrDefault = function() {
636
  return /** @type {number} */ (this.get$ValueOrDefault(12));
637
};
638

639

640
/**
641
 * Sets the value of the optional_double field.
642
 * @param {number} value The value.
643
 */
644
proto2.TestAllTypes.prototype.setOptionalDouble = function(value) {
645
  this.set$Value(12, value);
646
};
647

648

649
/**
650
 * @return {boolean} Whether the optional_double field has a value.
651
 */
652
proto2.TestAllTypes.prototype.hasOptionalDouble = function() {
653
  return this.has$Value(12);
654
};
655

656

657
/**
658
 * @return {number} The number of values in the optional_double field.
659
 */
660
proto2.TestAllTypes.prototype.optionalDoubleCount = function() {
661
  return this.count$Values(12);
662
};
663

664

665
/**
666
 * Clears the values in the optional_double field.
667
 */
668
proto2.TestAllTypes.prototype.clearOptionalDouble = function() {
669
  this.clear$Field(12);
670
};
671

672

673
/**
674
 * Gets the value of the optional_bool field.
675
 * @return {?boolean} The value.
676
 */
677
proto2.TestAllTypes.prototype.getOptionalBool = function() {
678
  return /** @type {?boolean} */ (this.get$Value(13));
679
};
680

681

682
/**
683
 * Gets the value of the optional_bool field or the default value if not set.
684
 * @return {boolean} The value.
685
 */
686
proto2.TestAllTypes.prototype.getOptionalBoolOrDefault = function() {
687
  return /** @type {boolean} */ (this.get$ValueOrDefault(13));
688
};
689

690

691
/**
692
 * Sets the value of the optional_bool field.
693
 * @param {boolean} value The value.
694
 */
695
proto2.TestAllTypes.prototype.setOptionalBool = function(value) {
696
  this.set$Value(13, value);
697
};
698

699

700
/**
701
 * @return {boolean} Whether the optional_bool field has a value.
702
 */
703
proto2.TestAllTypes.prototype.hasOptionalBool = function() {
704
  return this.has$Value(13);
705
};
706

707

708
/**
709
 * @return {number} The number of values in the optional_bool field.
710
 */
711
proto2.TestAllTypes.prototype.optionalBoolCount = function() {
712
  return this.count$Values(13);
713
};
714

715

716
/**
717
 * Clears the values in the optional_bool field.
718
 */
719
proto2.TestAllTypes.prototype.clearOptionalBool = function() {
720
  this.clear$Field(13);
721
};
722

723

724
/**
725
 * Gets the value of the optional_string field.
726
 * @return {?string} The value.
727
 */
728
proto2.TestAllTypes.prototype.getOptionalString = function() {
729
  return /** @type {?string} */ (this.get$Value(14));
730
};
731

732

733
/**
734
 * Gets the value of the optional_string field or the default value if not set.
735
 * @return {string} The value.
736
 */
737
proto2.TestAllTypes.prototype.getOptionalStringOrDefault = function() {
738
  return /** @type {string} */ (this.get$ValueOrDefault(14));
739
};
740

741

742
/**
743
 * Sets the value of the optional_string field.
744
 * @param {string} value The value.
745
 */
746
proto2.TestAllTypes.prototype.setOptionalString = function(value) {
747
  this.set$Value(14, value);
748
};
749

750

751
/**
752
 * @return {boolean} Whether the optional_string field has a value.
753
 */
754
proto2.TestAllTypes.prototype.hasOptionalString = function() {
755
  return this.has$Value(14);
756
};
757

758

759
/**
760
 * @return {number} The number of values in the optional_string field.
761
 */
762
proto2.TestAllTypes.prototype.optionalStringCount = function() {
763
  return this.count$Values(14);
764
};
765

766

767
/**
768
 * Clears the values in the optional_string field.
769
 */
770
proto2.TestAllTypes.prototype.clearOptionalString = function() {
771
  this.clear$Field(14);
772
};
773

774

775
/**
776
 * Gets the value of the optional_bytes field.
777
 * @return {?string} The value.
778
 */
779
proto2.TestAllTypes.prototype.getOptionalBytes = function() {
780
  return /** @type {?string} */ (this.get$Value(15));
781
};
782

783

784
/**
785
 * Gets the value of the optional_bytes field or the default value if not set.
786
 * @return {string} The value.
787
 */
788
proto2.TestAllTypes.prototype.getOptionalBytesOrDefault = function() {
789
  return /** @type {string} */ (this.get$ValueOrDefault(15));
790
};
791

792

793
/**
794
 * Sets the value of the optional_bytes field.
795
 * @param {string} value The value.
796
 */
797
proto2.TestAllTypes.prototype.setOptionalBytes = function(value) {
798
  this.set$Value(15, value);
799
};
800

801

802
/**
803
 * @return {boolean} Whether the optional_bytes field has a value.
804
 */
805
proto2.TestAllTypes.prototype.hasOptionalBytes = function() {
806
  return this.has$Value(15);
807
};
808

809

810
/**
811
 * @return {number} The number of values in the optional_bytes field.
812
 */
813
proto2.TestAllTypes.prototype.optionalBytesCount = function() {
814
  return this.count$Values(15);
815
};
816

817

818
/**
819
 * Clears the values in the optional_bytes field.
820
 */
821
proto2.TestAllTypes.prototype.clearOptionalBytes = function() {
822
  this.clear$Field(15);
823
};
824

825

826
/**
827
 * Gets the value of the optionalgroup field.
828
 * @return {?proto2.TestAllTypes.OptionalGroup} The value.
829
 */
830
proto2.TestAllTypes.prototype.getOptionalgroup = function() {
831
  return /** @type {?proto2.TestAllTypes.OptionalGroup} */ (this.get$Value(16));
832
};
833

834

835
/**
836
 * Gets the value of the optionalgroup field or the default value if not set.
837
 * @return {!proto2.TestAllTypes.OptionalGroup} The value.
838
 */
839
proto2.TestAllTypes.prototype.getOptionalgroupOrDefault = function() {
840
  return /** @type {!proto2.TestAllTypes.OptionalGroup} */ (this.get$ValueOrDefault(16));
841
};
842

843

844
/**
845
 * Sets the value of the optionalgroup field.
846
 * @param {!proto2.TestAllTypes.OptionalGroup} value The value.
847
 */
848
proto2.TestAllTypes.prototype.setOptionalgroup = function(value) {
849
  this.set$Value(16, value);
850
};
851

852

853
/**
854
 * @return {boolean} Whether the optionalgroup field has a value.
855
 */
856
proto2.TestAllTypes.prototype.hasOptionalgroup = function() {
857
  return this.has$Value(16);
858
};
859

860

861
/**
862
 * @return {number} The number of values in the optionalgroup field.
863
 */
864
proto2.TestAllTypes.prototype.optionalgroupCount = function() {
865
  return this.count$Values(16);
866
};
867

868

869
/**
870
 * Clears the values in the optionalgroup field.
871
 */
872
proto2.TestAllTypes.prototype.clearOptionalgroup = function() {
873
  this.clear$Field(16);
874
};
875

876

877
/**
878
 * Gets the value of the optional_nested_message field.
879
 * @return {?proto2.TestAllTypes.NestedMessage} The value.
880
 */
881
proto2.TestAllTypes.prototype.getOptionalNestedMessage = function() {
882
  return /** @type {?proto2.TestAllTypes.NestedMessage} */ (this.get$Value(18));
883
};
884

885

886
/**
887
 * Gets the value of the optional_nested_message field or the default value if not set.
888
 * @return {!proto2.TestAllTypes.NestedMessage} The value.
889
 */
890
proto2.TestAllTypes.prototype.getOptionalNestedMessageOrDefault = function() {
891
  return /** @type {!proto2.TestAllTypes.NestedMessage} */ (this.get$ValueOrDefault(18));
892
};
893

894

895
/**
896
 * Sets the value of the optional_nested_message field.
897
 * @param {!proto2.TestAllTypes.NestedMessage} value The value.
898
 */
899
proto2.TestAllTypes.prototype.setOptionalNestedMessage = function(value) {
900
  this.set$Value(18, value);
901
};
902

903

904
/**
905
 * @return {boolean} Whether the optional_nested_message field has a value.
906
 */
907
proto2.TestAllTypes.prototype.hasOptionalNestedMessage = function() {
908
  return this.has$Value(18);
909
};
910

911

912
/**
913
 * @return {number} The number of values in the optional_nested_message field.
914
 */
915
proto2.TestAllTypes.prototype.optionalNestedMessageCount = function() {
916
  return this.count$Values(18);
917
};
918

919

920
/**
921
 * Clears the values in the optional_nested_message field.
922
 */
923
proto2.TestAllTypes.prototype.clearOptionalNestedMessage = function() {
924
  this.clear$Field(18);
925
};
926

927

928
/**
929
 * Gets the value of the optional_nested_enum field.
930
 * @return {?proto2.TestAllTypes.NestedEnum} The value.
931
 */
932
proto2.TestAllTypes.prototype.getOptionalNestedEnum = function() {
933
  return /** @type {?proto2.TestAllTypes.NestedEnum} */ (this.get$Value(21));
934
};
935

936

937
/**
938
 * Gets the value of the optional_nested_enum field or the default value if not set.
939
 * @return {!proto2.TestAllTypes.NestedEnum} The value.
940
 */
941
proto2.TestAllTypes.prototype.getOptionalNestedEnumOrDefault = function() {
942
  return /** @type {!proto2.TestAllTypes.NestedEnum} */ (this.get$ValueOrDefault(21));
943
};
944

945

946
/**
947
 * Sets the value of the optional_nested_enum field.
948
 * @param {!proto2.TestAllTypes.NestedEnum} value The value.
949
 */
950
proto2.TestAllTypes.prototype.setOptionalNestedEnum = function(value) {
951
  this.set$Value(21, value);
952
};
953

954

955
/**
956
 * @return {boolean} Whether the optional_nested_enum field has a value.
957
 */
958
proto2.TestAllTypes.prototype.hasOptionalNestedEnum = function() {
959
  return this.has$Value(21);
960
};
961

962

963
/**
964
 * @return {number} The number of values in the optional_nested_enum field.
965
 */
966
proto2.TestAllTypes.prototype.optionalNestedEnumCount = function() {
967
  return this.count$Values(21);
968
};
969

970

971
/**
972
 * Clears the values in the optional_nested_enum field.
973
 */
974
proto2.TestAllTypes.prototype.clearOptionalNestedEnum = function() {
975
  this.clear$Field(21);
976
};
977

978

979
/**
980
 * Gets the value of the optional_int64_number field.
981
 * @return {?number} The value.
982
 */
983
proto2.TestAllTypes.prototype.getOptionalInt64Number = function() {
984
  return /** @type {?number} */ (this.get$Value(50));
985
};
986

987

988
/**
989
 * Gets the value of the optional_int64_number field or the default value if not set.
990
 * @return {number} The value.
991
 */
992
proto2.TestAllTypes.prototype.getOptionalInt64NumberOrDefault = function() {
993
  return /** @type {number} */ (this.get$ValueOrDefault(50));
994
};
995

996

997
/**
998
 * Sets the value of the optional_int64_number field.
999
 * @param {number} value The value.
1000
 */
1001
proto2.TestAllTypes.prototype.setOptionalInt64Number = function(value) {
1002
  this.set$Value(50, value);
1003
};
1004

1005

1006
/**
1007
 * @return {boolean} Whether the optional_int64_number field has a value.
1008
 */
1009
proto2.TestAllTypes.prototype.hasOptionalInt64Number = function() {
1010
  return this.has$Value(50);
1011
};
1012

1013

1014
/**
1015
 * @return {number} The number of values in the optional_int64_number field.
1016
 */
1017
proto2.TestAllTypes.prototype.optionalInt64NumberCount = function() {
1018
  return this.count$Values(50);
1019
};
1020

1021

1022
/**
1023
 * Clears the values in the optional_int64_number field.
1024
 */
1025
proto2.TestAllTypes.prototype.clearOptionalInt64Number = function() {
1026
  this.clear$Field(50);
1027
};
1028

1029

1030
/**
1031
 * Gets the value of the optional_int64_string field.
1032
 * @return {?string} The value.
1033
 */
1034
proto2.TestAllTypes.prototype.getOptionalInt64String = function() {
1035
  return /** @type {?string} */ (this.get$Value(51));
1036
};
1037

1038

1039
/**
1040
 * Gets the value of the optional_int64_string field or the default value if not set.
1041
 * @return {string} The value.
1042
 */
1043
proto2.TestAllTypes.prototype.getOptionalInt64StringOrDefault = function() {
1044
  return /** @type {string} */ (this.get$ValueOrDefault(51));
1045
};
1046

1047

1048
/**
1049
 * Sets the value of the optional_int64_string field.
1050
 * @param {string} value The value.
1051
 */
1052
proto2.TestAllTypes.prototype.setOptionalInt64String = function(value) {
1053
  this.set$Value(51, value);
1054
};
1055

1056

1057
/**
1058
 * @return {boolean} Whether the optional_int64_string field has a value.
1059
 */
1060
proto2.TestAllTypes.prototype.hasOptionalInt64String = function() {
1061
  return this.has$Value(51);
1062
};
1063

1064

1065
/**
1066
 * @return {number} The number of values in the optional_int64_string field.
1067
 */
1068
proto2.TestAllTypes.prototype.optionalInt64StringCount = function() {
1069
  return this.count$Values(51);
1070
};
1071

1072

1073
/**
1074
 * Clears the values in the optional_int64_string field.
1075
 */
1076
proto2.TestAllTypes.prototype.clearOptionalInt64String = function() {
1077
  this.clear$Field(51);
1078
};
1079

1080

1081
/**
1082
 * Gets the value of the repeated_int32 field at the index given.
1083
 * @param {number} index The index to lookup.
1084
 * @return {?number} The value.
1085
 */
1086
proto2.TestAllTypes.prototype.getRepeatedInt32 = function(index) {
1087
  return /** @type {?number} */ (this.get$Value(31, index));
1088
};
1089

1090

1091
/**
1092
 * Gets the value of the repeated_int32 field at the index given or the default value if not set.
1093
 * @param {number} index The index to lookup.
1094
 * @return {number} The value.
1095
 */
1096
proto2.TestAllTypes.prototype.getRepeatedInt32OrDefault = function(index) {
1097
  return /** @type {number} */ (this.get$ValueOrDefault(31, index));
1098
};
1099

1100

1101
/**
1102
 * Adds a value to the repeated_int32 field.
1103
 * @param {number} value The value to add.
1104
 */
1105
proto2.TestAllTypes.prototype.addRepeatedInt32 = function(value) {
1106
  this.add$Value(31, value);
1107
};
1108

1109

1110
/**
1111
 * Returns the array of values in the repeated_int32 field.
1112
 * @return {!Array<number>} The values in the field.
1113
 */
1114
proto2.TestAllTypes.prototype.repeatedInt32Array = function() {
1115
  return /** @type {!Array<number>} */ (this.array$Values(31));
1116
};
1117

1118

1119
/**
1120
 * @return {boolean} Whether the repeated_int32 field has a value.
1121
 */
1122
proto2.TestAllTypes.prototype.hasRepeatedInt32 = function() {
1123
  return this.has$Value(31);
1124
};
1125

1126

1127
/**
1128
 * @return {number} The number of values in the repeated_int32 field.
1129
 */
1130
proto2.TestAllTypes.prototype.repeatedInt32Count = function() {
1131
  return this.count$Values(31);
1132
};
1133

1134

1135
/**
1136
 * Clears the values in the repeated_int32 field.
1137
 */
1138
proto2.TestAllTypes.prototype.clearRepeatedInt32 = function() {
1139
  this.clear$Field(31);
1140
};
1141

1142

1143
/**
1144
 * Gets the value of the repeated_int64 field at the index given.
1145
 * @param {number} index The index to lookup.
1146
 * @return {?string} The value.
1147
 */
1148
proto2.TestAllTypes.prototype.getRepeatedInt64 = function(index) {
1149
  return /** @type {?string} */ (this.get$Value(32, index));
1150
};
1151

1152

1153
/**
1154
 * Gets the value of the repeated_int64 field at the index given or the default value if not set.
1155
 * @param {number} index The index to lookup.
1156
 * @return {string} The value.
1157
 */
1158
proto2.TestAllTypes.prototype.getRepeatedInt64OrDefault = function(index) {
1159
  return /** @type {string} */ (this.get$ValueOrDefault(32, index));
1160
};
1161

1162

1163
/**
1164
 * Adds a value to the repeated_int64 field.
1165
 * @param {string} value The value to add.
1166
 */
1167
proto2.TestAllTypes.prototype.addRepeatedInt64 = function(value) {
1168
  this.add$Value(32, value);
1169
};
1170

1171

1172
/**
1173
 * Returns the array of values in the repeated_int64 field.
1174
 * @return {!Array<string>} The values in the field.
1175
 */
1176
proto2.TestAllTypes.prototype.repeatedInt64Array = function() {
1177
  return /** @type {!Array<string>} */ (this.array$Values(32));
1178
};
1179

1180

1181
/**
1182
 * @return {boolean} Whether the repeated_int64 field has a value.
1183
 */
1184
proto2.TestAllTypes.prototype.hasRepeatedInt64 = function() {
1185
  return this.has$Value(32);
1186
};
1187

1188

1189
/**
1190
 * @return {number} The number of values in the repeated_int64 field.
1191
 */
1192
proto2.TestAllTypes.prototype.repeatedInt64Count = function() {
1193
  return this.count$Values(32);
1194
};
1195

1196

1197
/**
1198
 * Clears the values in the repeated_int64 field.
1199
 */
1200
proto2.TestAllTypes.prototype.clearRepeatedInt64 = function() {
1201
  this.clear$Field(32);
1202
};
1203

1204

1205
/**
1206
 * Gets the value of the repeated_uint32 field at the index given.
1207
 * @param {number} index The index to lookup.
1208
 * @return {?number} The value.
1209
 */
1210
proto2.TestAllTypes.prototype.getRepeatedUint32 = function(index) {
1211
  return /** @type {?number} */ (this.get$Value(33, index));
1212
};
1213

1214

1215
/**
1216
 * Gets the value of the repeated_uint32 field at the index given or the default value if not set.
1217
 * @param {number} index The index to lookup.
1218
 * @return {number} The value.
1219
 */
1220
proto2.TestAllTypes.prototype.getRepeatedUint32OrDefault = function(index) {
1221
  return /** @type {number} */ (this.get$ValueOrDefault(33, index));
1222
};
1223

1224

1225
/**
1226
 * Adds a value to the repeated_uint32 field.
1227
 * @param {number} value The value to add.
1228
 */
1229
proto2.TestAllTypes.prototype.addRepeatedUint32 = function(value) {
1230
  this.add$Value(33, value);
1231
};
1232

1233

1234
/**
1235
 * Returns the array of values in the repeated_uint32 field.
1236
 * @return {!Array<number>} The values in the field.
1237
 */
1238
proto2.TestAllTypes.prototype.repeatedUint32Array = function() {
1239
  return /** @type {!Array<number>} */ (this.array$Values(33));
1240
};
1241

1242

1243
/**
1244
 * @return {boolean} Whether the repeated_uint32 field has a value.
1245
 */
1246
proto2.TestAllTypes.prototype.hasRepeatedUint32 = function() {
1247
  return this.has$Value(33);
1248
};
1249

1250

1251
/**
1252
 * @return {number} The number of values in the repeated_uint32 field.
1253
 */
1254
proto2.TestAllTypes.prototype.repeatedUint32Count = function() {
1255
  return this.count$Values(33);
1256
};
1257

1258

1259
/**
1260
 * Clears the values in the repeated_uint32 field.
1261
 */
1262
proto2.TestAllTypes.prototype.clearRepeatedUint32 = function() {
1263
  this.clear$Field(33);
1264
};
1265

1266

1267
/**
1268
 * Gets the value of the repeated_uint64 field at the index given.
1269
 * @param {number} index The index to lookup.
1270
 * @return {?string} The value.
1271
 */
1272
proto2.TestAllTypes.prototype.getRepeatedUint64 = function(index) {
1273
  return /** @type {?string} */ (this.get$Value(34, index));
1274
};
1275

1276

1277
/**
1278
 * Gets the value of the repeated_uint64 field at the index given or the default value if not set.
1279
 * @param {number} index The index to lookup.
1280
 * @return {string} The value.
1281
 */
1282
proto2.TestAllTypes.prototype.getRepeatedUint64OrDefault = function(index) {
1283
  return /** @type {string} */ (this.get$ValueOrDefault(34, index));
1284
};
1285

1286

1287
/**
1288
 * Adds a value to the repeated_uint64 field.
1289
 * @param {string} value The value to add.
1290
 */
1291
proto2.TestAllTypes.prototype.addRepeatedUint64 = function(value) {
1292
  this.add$Value(34, value);
1293
};
1294

1295

1296
/**
1297
 * Returns the array of values in the repeated_uint64 field.
1298
 * @return {!Array<string>} The values in the field.
1299
 */
1300
proto2.TestAllTypes.prototype.repeatedUint64Array = function() {
1301
  return /** @type {!Array<string>} */ (this.array$Values(34));
1302
};
1303

1304

1305
/**
1306
 * @return {boolean} Whether the repeated_uint64 field has a value.
1307
 */
1308
proto2.TestAllTypes.prototype.hasRepeatedUint64 = function() {
1309
  return this.has$Value(34);
1310
};
1311

1312

1313
/**
1314
 * @return {number} The number of values in the repeated_uint64 field.
1315
 */
1316
proto2.TestAllTypes.prototype.repeatedUint64Count = function() {
1317
  return this.count$Values(34);
1318
};
1319

1320

1321
/**
1322
 * Clears the values in the repeated_uint64 field.
1323
 */
1324
proto2.TestAllTypes.prototype.clearRepeatedUint64 = function() {
1325
  this.clear$Field(34);
1326
};
1327

1328

1329
/**
1330
 * Gets the value of the repeated_sint32 field at the index given.
1331
 * @param {number} index The index to lookup.
1332
 * @return {?number} The value.
1333
 */
1334
proto2.TestAllTypes.prototype.getRepeatedSint32 = function(index) {
1335
  return /** @type {?number} */ (this.get$Value(35, index));
1336
};
1337

1338

1339
/**
1340
 * Gets the value of the repeated_sint32 field at the index given or the default value if not set.
1341
 * @param {number} index The index to lookup.
1342
 * @return {number} The value.
1343
 */
1344
proto2.TestAllTypes.prototype.getRepeatedSint32OrDefault = function(index) {
1345
  return /** @type {number} */ (this.get$ValueOrDefault(35, index));
1346
};
1347

1348

1349
/**
1350
 * Adds a value to the repeated_sint32 field.
1351
 * @param {number} value The value to add.
1352
 */
1353
proto2.TestAllTypes.prototype.addRepeatedSint32 = function(value) {
1354
  this.add$Value(35, value);
1355
};
1356

1357

1358
/**
1359
 * Returns the array of values in the repeated_sint32 field.
1360
 * @return {!Array<number>} The values in the field.
1361
 */
1362
proto2.TestAllTypes.prototype.repeatedSint32Array = function() {
1363
  return /** @type {!Array<number>} */ (this.array$Values(35));
1364
};
1365

1366

1367
/**
1368
 * @return {boolean} Whether the repeated_sint32 field has a value.
1369
 */
1370
proto2.TestAllTypes.prototype.hasRepeatedSint32 = function() {
1371
  return this.has$Value(35);
1372
};
1373

1374

1375
/**
1376
 * @return {number} The number of values in the repeated_sint32 field.
1377
 */
1378
proto2.TestAllTypes.prototype.repeatedSint32Count = function() {
1379
  return this.count$Values(35);
1380
};
1381

1382

1383
/**
1384
 * Clears the values in the repeated_sint32 field.
1385
 */
1386
proto2.TestAllTypes.prototype.clearRepeatedSint32 = function() {
1387
  this.clear$Field(35);
1388
};
1389

1390

1391
/**
1392
 * Gets the value of the repeated_sint64 field at the index given.
1393
 * @param {number} index The index to lookup.
1394
 * @return {?string} The value.
1395
 */
1396
proto2.TestAllTypes.prototype.getRepeatedSint64 = function(index) {
1397
  return /** @type {?string} */ (this.get$Value(36, index));
1398
};
1399

1400

1401
/**
1402
 * Gets the value of the repeated_sint64 field at the index given or the default value if not set.
1403
 * @param {number} index The index to lookup.
1404
 * @return {string} The value.
1405
 */
1406
proto2.TestAllTypes.prototype.getRepeatedSint64OrDefault = function(index) {
1407
  return /** @type {string} */ (this.get$ValueOrDefault(36, index));
1408
};
1409

1410

1411
/**
1412
 * Adds a value to the repeated_sint64 field.
1413
 * @param {string} value The value to add.
1414
 */
1415
proto2.TestAllTypes.prototype.addRepeatedSint64 = function(value) {
1416
  this.add$Value(36, value);
1417
};
1418

1419

1420
/**
1421
 * Returns the array of values in the repeated_sint64 field.
1422
 * @return {!Array<string>} The values in the field.
1423
 */
1424
proto2.TestAllTypes.prototype.repeatedSint64Array = function() {
1425
  return /** @type {!Array<string>} */ (this.array$Values(36));
1426
};
1427

1428

1429
/**
1430
 * @return {boolean} Whether the repeated_sint64 field has a value.
1431
 */
1432
proto2.TestAllTypes.prototype.hasRepeatedSint64 = function() {
1433
  return this.has$Value(36);
1434
};
1435

1436

1437
/**
1438
 * @return {number} The number of values in the repeated_sint64 field.
1439
 */
1440
proto2.TestAllTypes.prototype.repeatedSint64Count = function() {
1441
  return this.count$Values(36);
1442
};
1443

1444

1445
/**
1446
 * Clears the values in the repeated_sint64 field.
1447
 */
1448
proto2.TestAllTypes.prototype.clearRepeatedSint64 = function() {
1449
  this.clear$Field(36);
1450
};
1451

1452

1453
/**
1454
 * Gets the value of the repeated_fixed32 field at the index given.
1455
 * @param {number} index The index to lookup.
1456
 * @return {?number} The value.
1457
 */
1458
proto2.TestAllTypes.prototype.getRepeatedFixed32 = function(index) {
1459
  return /** @type {?number} */ (this.get$Value(37, index));
1460
};
1461

1462

1463
/**
1464
 * Gets the value of the repeated_fixed32 field at the index given or the default value if not set.
1465
 * @param {number} index The index to lookup.
1466
 * @return {number} The value.
1467
 */
1468
proto2.TestAllTypes.prototype.getRepeatedFixed32OrDefault = function(index) {
1469
  return /** @type {number} */ (this.get$ValueOrDefault(37, index));
1470
};
1471

1472

1473
/**
1474
 * Adds a value to the repeated_fixed32 field.
1475
 * @param {number} value The value to add.
1476
 */
1477
proto2.TestAllTypes.prototype.addRepeatedFixed32 = function(value) {
1478
  this.add$Value(37, value);
1479
};
1480

1481

1482
/**
1483
 * Returns the array of values in the repeated_fixed32 field.
1484
 * @return {!Array<number>} The values in the field.
1485
 */
1486
proto2.TestAllTypes.prototype.repeatedFixed32Array = function() {
1487
  return /** @type {!Array<number>} */ (this.array$Values(37));
1488
};
1489

1490

1491
/**
1492
 * @return {boolean} Whether the repeated_fixed32 field has a value.
1493
 */
1494
proto2.TestAllTypes.prototype.hasRepeatedFixed32 = function() {
1495
  return this.has$Value(37);
1496
};
1497

1498

1499
/**
1500
 * @return {number} The number of values in the repeated_fixed32 field.
1501
 */
1502
proto2.TestAllTypes.prototype.repeatedFixed32Count = function() {
1503
  return this.count$Values(37);
1504
};
1505

1506

1507
/**
1508
 * Clears the values in the repeated_fixed32 field.
1509
 */
1510
proto2.TestAllTypes.prototype.clearRepeatedFixed32 = function() {
1511
  this.clear$Field(37);
1512
};
1513

1514

1515
/**
1516
 * Gets the value of the repeated_fixed64 field at the index given.
1517
 * @param {number} index The index to lookup.
1518
 * @return {?string} The value.
1519
 */
1520
proto2.TestAllTypes.prototype.getRepeatedFixed64 = function(index) {
1521
  return /** @type {?string} */ (this.get$Value(38, index));
1522
};
1523

1524

1525
/**
1526
 * Gets the value of the repeated_fixed64 field at the index given or the default value if not set.
1527
 * @param {number} index The index to lookup.
1528
 * @return {string} The value.
1529
 */
1530
proto2.TestAllTypes.prototype.getRepeatedFixed64OrDefault = function(index) {
1531
  return /** @type {string} */ (this.get$ValueOrDefault(38, index));
1532
};
1533

1534

1535
/**
1536
 * Adds a value to the repeated_fixed64 field.
1537
 * @param {string} value The value to add.
1538
 */
1539
proto2.TestAllTypes.prototype.addRepeatedFixed64 = function(value) {
1540
  this.add$Value(38, value);
1541
};
1542

1543

1544
/**
1545
 * Returns the array of values in the repeated_fixed64 field.
1546
 * @return {!Array<string>} The values in the field.
1547
 */
1548
proto2.TestAllTypes.prototype.repeatedFixed64Array = function() {
1549
  return /** @type {!Array<string>} */ (this.array$Values(38));
1550
};
1551

1552

1553
/**
1554
 * @return {boolean} Whether the repeated_fixed64 field has a value.
1555
 */
1556
proto2.TestAllTypes.prototype.hasRepeatedFixed64 = function() {
1557
  return this.has$Value(38);
1558
};
1559

1560

1561
/**
1562
 * @return {number} The number of values in the repeated_fixed64 field.
1563
 */
1564
proto2.TestAllTypes.prototype.repeatedFixed64Count = function() {
1565
  return this.count$Values(38);
1566
};
1567

1568

1569
/**
1570
 * Clears the values in the repeated_fixed64 field.
1571
 */
1572
proto2.TestAllTypes.prototype.clearRepeatedFixed64 = function() {
1573
  this.clear$Field(38);
1574
};
1575

1576

1577
/**
1578
 * Gets the value of the repeated_sfixed32 field at the index given.
1579
 * @param {number} index The index to lookup.
1580
 * @return {?number} The value.
1581
 */
1582
proto2.TestAllTypes.prototype.getRepeatedSfixed32 = function(index) {
1583
  return /** @type {?number} */ (this.get$Value(39, index));
1584
};
1585

1586

1587
/**
1588
 * Gets the value of the repeated_sfixed32 field at the index given or the default value if not set.
1589
 * @param {number} index The index to lookup.
1590
 * @return {number} The value.
1591
 */
1592
proto2.TestAllTypes.prototype.getRepeatedSfixed32OrDefault = function(index) {
1593
  return /** @type {number} */ (this.get$ValueOrDefault(39, index));
1594
};
1595

1596

1597
/**
1598
 * Adds a value to the repeated_sfixed32 field.
1599
 * @param {number} value The value to add.
1600
 */
1601
proto2.TestAllTypes.prototype.addRepeatedSfixed32 = function(value) {
1602
  this.add$Value(39, value);
1603
};
1604

1605

1606
/**
1607
 * Returns the array of values in the repeated_sfixed32 field.
1608
 * @return {!Array<number>} The values in the field.
1609
 */
1610
proto2.TestAllTypes.prototype.repeatedSfixed32Array = function() {
1611
  return /** @type {!Array<number>} */ (this.array$Values(39));
1612
};
1613

1614

1615
/**
1616
 * @return {boolean} Whether the repeated_sfixed32 field has a value.
1617
 */
1618
proto2.TestAllTypes.prototype.hasRepeatedSfixed32 = function() {
1619
  return this.has$Value(39);
1620
};
1621

1622

1623
/**
1624
 * @return {number} The number of values in the repeated_sfixed32 field.
1625
 */
1626
proto2.TestAllTypes.prototype.repeatedSfixed32Count = function() {
1627
  return this.count$Values(39);
1628
};
1629

1630

1631
/**
1632
 * Clears the values in the repeated_sfixed32 field.
1633
 */
1634
proto2.TestAllTypes.prototype.clearRepeatedSfixed32 = function() {
1635
  this.clear$Field(39);
1636
};
1637

1638

1639
/**
1640
 * Gets the value of the repeated_sfixed64 field at the index given.
1641
 * @param {number} index The index to lookup.
1642
 * @return {?string} The value.
1643
 */
1644
proto2.TestAllTypes.prototype.getRepeatedSfixed64 = function(index) {
1645
  return /** @type {?string} */ (this.get$Value(40, index));
1646
};
1647

1648

1649
/**
1650
 * Gets the value of the repeated_sfixed64 field at the index given or the default value if not set.
1651
 * @param {number} index The index to lookup.
1652
 * @return {string} The value.
1653
 */
1654
proto2.TestAllTypes.prototype.getRepeatedSfixed64OrDefault = function(index) {
1655
  return /** @type {string} */ (this.get$ValueOrDefault(40, index));
1656
};
1657

1658

1659
/**
1660
 * Adds a value to the repeated_sfixed64 field.
1661
 * @param {string} value The value to add.
1662
 */
1663
proto2.TestAllTypes.prototype.addRepeatedSfixed64 = function(value) {
1664
  this.add$Value(40, value);
1665
};
1666

1667

1668
/**
1669
 * Returns the array of values in the repeated_sfixed64 field.
1670
 * @return {!Array<string>} The values in the field.
1671
 */
1672
proto2.TestAllTypes.prototype.repeatedSfixed64Array = function() {
1673
  return /** @type {!Array<string>} */ (this.array$Values(40));
1674
};
1675

1676

1677
/**
1678
 * @return {boolean} Whether the repeated_sfixed64 field has a value.
1679
 */
1680
proto2.TestAllTypes.prototype.hasRepeatedSfixed64 = function() {
1681
  return this.has$Value(40);
1682
};
1683

1684

1685
/**
1686
 * @return {number} The number of values in the repeated_sfixed64 field.
1687
 */
1688
proto2.TestAllTypes.prototype.repeatedSfixed64Count = function() {
1689
  return this.count$Values(40);
1690
};
1691

1692

1693
/**
1694
 * Clears the values in the repeated_sfixed64 field.
1695
 */
1696
proto2.TestAllTypes.prototype.clearRepeatedSfixed64 = function() {
1697
  this.clear$Field(40);
1698
};
1699

1700

1701
/**
1702
 * Gets the value of the repeated_float field at the index given.
1703
 * @param {number} index The index to lookup.
1704
 * @return {?number} The value.
1705
 */
1706
proto2.TestAllTypes.prototype.getRepeatedFloat = function(index) {
1707
  return /** @type {?number} */ (this.get$Value(41, index));
1708
};
1709

1710

1711
/**
1712
 * Gets the value of the repeated_float field at the index given or the default value if not set.
1713
 * @param {number} index The index to lookup.
1714
 * @return {number} The value.
1715
 */
1716
proto2.TestAllTypes.prototype.getRepeatedFloatOrDefault = function(index) {
1717
  return /** @type {number} */ (this.get$ValueOrDefault(41, index));
1718
};
1719

1720

1721
/**
1722
 * Adds a value to the repeated_float field.
1723
 * @param {number} value The value to add.
1724
 */
1725
proto2.TestAllTypes.prototype.addRepeatedFloat = function(value) {
1726
  this.add$Value(41, value);
1727
};
1728

1729

1730
/**
1731
 * Returns the array of values in the repeated_float field.
1732
 * @return {!Array<number>} The values in the field.
1733
 */
1734
proto2.TestAllTypes.prototype.repeatedFloatArray = function() {
1735
  return /** @type {!Array<number>} */ (this.array$Values(41));
1736
};
1737

1738

1739
/**
1740
 * @return {boolean} Whether the repeated_float field has a value.
1741
 */
1742
proto2.TestAllTypes.prototype.hasRepeatedFloat = function() {
1743
  return this.has$Value(41);
1744
};
1745

1746

1747
/**
1748
 * @return {number} The number of values in the repeated_float field.
1749
 */
1750
proto2.TestAllTypes.prototype.repeatedFloatCount = function() {
1751
  return this.count$Values(41);
1752
};
1753

1754

1755
/**
1756
 * Clears the values in the repeated_float field.
1757
 */
1758
proto2.TestAllTypes.prototype.clearRepeatedFloat = function() {
1759
  this.clear$Field(41);
1760
};
1761

1762

1763
/**
1764
 * Gets the value of the repeated_double field at the index given.
1765
 * @param {number} index The index to lookup.
1766
 * @return {?number} The value.
1767
 */
1768
proto2.TestAllTypes.prototype.getRepeatedDouble = function(index) {
1769
  return /** @type {?number} */ (this.get$Value(42, index));
1770
};
1771

1772

1773
/**
1774
 * Gets the value of the repeated_double field at the index given or the default value if not set.
1775
 * @param {number} index The index to lookup.
1776
 * @return {number} The value.
1777
 */
1778
proto2.TestAllTypes.prototype.getRepeatedDoubleOrDefault = function(index) {
1779
  return /** @type {number} */ (this.get$ValueOrDefault(42, index));
1780
};
1781

1782

1783
/**
1784
 * Adds a value to the repeated_double field.
1785
 * @param {number} value The value to add.
1786
 */
1787
proto2.TestAllTypes.prototype.addRepeatedDouble = function(value) {
1788
  this.add$Value(42, value);
1789
};
1790

1791

1792
/**
1793
 * Returns the array of values in the repeated_double field.
1794
 * @return {!Array<number>} The values in the field.
1795
 */
1796
proto2.TestAllTypes.prototype.repeatedDoubleArray = function() {
1797
  return /** @type {!Array<number>} */ (this.array$Values(42));
1798
};
1799

1800

1801
/**
1802
 * @return {boolean} Whether the repeated_double field has a value.
1803
 */
1804
proto2.TestAllTypes.prototype.hasRepeatedDouble = function() {
1805
  return this.has$Value(42);
1806
};
1807

1808

1809
/**
1810
 * @return {number} The number of values in the repeated_double field.
1811
 */
1812
proto2.TestAllTypes.prototype.repeatedDoubleCount = function() {
1813
  return this.count$Values(42);
1814
};
1815

1816

1817
/**
1818
 * Clears the values in the repeated_double field.
1819
 */
1820
proto2.TestAllTypes.prototype.clearRepeatedDouble = function() {
1821
  this.clear$Field(42);
1822
};
1823

1824

1825
/**
1826
 * Gets the value of the repeated_bool field at the index given.
1827
 * @param {number} index The index to lookup.
1828
 * @return {?boolean} The value.
1829
 */
1830
proto2.TestAllTypes.prototype.getRepeatedBool = function(index) {
1831
  return /** @type {?boolean} */ (this.get$Value(43, index));
1832
};
1833

1834

1835
/**
1836
 * Gets the value of the repeated_bool field at the index given or the default value if not set.
1837
 * @param {number} index The index to lookup.
1838
 * @return {boolean} The value.
1839
 */
1840
proto2.TestAllTypes.prototype.getRepeatedBoolOrDefault = function(index) {
1841
  return /** @type {boolean} */ (this.get$ValueOrDefault(43, index));
1842
};
1843

1844

1845
/**
1846
 * Adds a value to the repeated_bool field.
1847
 * @param {boolean} value The value to add.
1848
 */
1849
proto2.TestAllTypes.prototype.addRepeatedBool = function(value) {
1850
  this.add$Value(43, value);
1851
};
1852

1853

1854
/**
1855
 * Returns the array of values in the repeated_bool field.
1856
 * @return {!Array<boolean>} The values in the field.
1857
 */
1858
proto2.TestAllTypes.prototype.repeatedBoolArray = function() {
1859
  return /** @type {!Array<boolean>} */ (this.array$Values(43));
1860
};
1861

1862

1863
/**
1864
 * @return {boolean} Whether the repeated_bool field has a value.
1865
 */
1866
proto2.TestAllTypes.prototype.hasRepeatedBool = function() {
1867
  return this.has$Value(43);
1868
};
1869

1870

1871
/**
1872
 * @return {number} The number of values in the repeated_bool field.
1873
 */
1874
proto2.TestAllTypes.prototype.repeatedBoolCount = function() {
1875
  return this.count$Values(43);
1876
};
1877

1878

1879
/**
1880
 * Clears the values in the repeated_bool field.
1881
 */
1882
proto2.TestAllTypes.prototype.clearRepeatedBool = function() {
1883
  this.clear$Field(43);
1884
};
1885

1886

1887
/**
1888
 * Gets the value of the repeated_string field at the index given.
1889
 * @param {number} index The index to lookup.
1890
 * @return {?string} The value.
1891
 */
1892
proto2.TestAllTypes.prototype.getRepeatedString = function(index) {
1893
  return /** @type {?string} */ (this.get$Value(44, index));
1894
};
1895

1896

1897
/**
1898
 * Gets the value of the repeated_string field at the index given or the default value if not set.
1899
 * @param {number} index The index to lookup.
1900
 * @return {string} The value.
1901
 */
1902
proto2.TestAllTypes.prototype.getRepeatedStringOrDefault = function(index) {
1903
  return /** @type {string} */ (this.get$ValueOrDefault(44, index));
1904
};
1905

1906

1907
/**
1908
 * Adds a value to the repeated_string field.
1909
 * @param {string} value The value to add.
1910
 */
1911
proto2.TestAllTypes.prototype.addRepeatedString = function(value) {
1912
  this.add$Value(44, value);
1913
};
1914

1915

1916
/**
1917
 * Returns the array of values in the repeated_string field.
1918
 * @return {!Array<string>} The values in the field.
1919
 */
1920
proto2.TestAllTypes.prototype.repeatedStringArray = function() {
1921
  return /** @type {!Array<string>} */ (this.array$Values(44));
1922
};
1923

1924

1925
/**
1926
 * @return {boolean} Whether the repeated_string field has a value.
1927
 */
1928
proto2.TestAllTypes.prototype.hasRepeatedString = function() {
1929
  return this.has$Value(44);
1930
};
1931

1932

1933
/**
1934
 * @return {number} The number of values in the repeated_string field.
1935
 */
1936
proto2.TestAllTypes.prototype.repeatedStringCount = function() {
1937
  return this.count$Values(44);
1938
};
1939

1940

1941
/**
1942
 * Clears the values in the repeated_string field.
1943
 */
1944
proto2.TestAllTypes.prototype.clearRepeatedString = function() {
1945
  this.clear$Field(44);
1946
};
1947

1948

1949
/**
1950
 * Gets the value of the repeated_bytes field at the index given.
1951
 * @param {number} index The index to lookup.
1952
 * @return {?string} The value.
1953
 */
1954
proto2.TestAllTypes.prototype.getRepeatedBytes = function(index) {
1955
  return /** @type {?string} */ (this.get$Value(45, index));
1956
};
1957

1958

1959
/**
1960
 * Gets the value of the repeated_bytes field at the index given or the default value if not set.
1961
 * @param {number} index The index to lookup.
1962
 * @return {string} The value.
1963
 */
1964
proto2.TestAllTypes.prototype.getRepeatedBytesOrDefault = function(index) {
1965
  return /** @type {string} */ (this.get$ValueOrDefault(45, index));
1966
};
1967

1968

1969
/**
1970
 * Adds a value to the repeated_bytes field.
1971
 * @param {string} value The value to add.
1972
 */
1973
proto2.TestAllTypes.prototype.addRepeatedBytes = function(value) {
1974
  this.add$Value(45, value);
1975
};
1976

1977

1978
/**
1979
 * Returns the array of values in the repeated_bytes field.
1980
 * @return {!Array<string>} The values in the field.
1981
 */
1982
proto2.TestAllTypes.prototype.repeatedBytesArray = function() {
1983
  return /** @type {!Array<string>} */ (this.array$Values(45));
1984
};
1985

1986

1987
/**
1988
 * @return {boolean} Whether the repeated_bytes field has a value.
1989
 */
1990
proto2.TestAllTypes.prototype.hasRepeatedBytes = function() {
1991
  return this.has$Value(45);
1992
};
1993

1994

1995
/**
1996
 * @return {number} The number of values in the repeated_bytes field.
1997
 */
1998
proto2.TestAllTypes.prototype.repeatedBytesCount = function() {
1999
  return this.count$Values(45);
2000
};
2001

2002

2003
/**
2004
 * Clears the values in the repeated_bytes field.
2005
 */
2006
proto2.TestAllTypes.prototype.clearRepeatedBytes = function() {
2007
  this.clear$Field(45);
2008
};
2009

2010

2011
/**
2012
 * Gets the value of the repeatedgroup field at the index given.
2013
 * @param {number} index The index to lookup.
2014
 * @return {?proto2.TestAllTypes.RepeatedGroup} The value.
2015
 */
2016
proto2.TestAllTypes.prototype.getRepeatedgroup = function(index) {
2017
  return /** @type {?proto2.TestAllTypes.RepeatedGroup} */ (this.get$Value(46, index));
2018
};
2019

2020

2021
/**
2022
 * Gets the value of the repeatedgroup field at the index given or the default value if not set.
2023
 * @param {number} index The index to lookup.
2024
 * @return {!proto2.TestAllTypes.RepeatedGroup} The value.
2025
 */
2026
proto2.TestAllTypes.prototype.getRepeatedgroupOrDefault = function(index) {
2027
  return /** @type {!proto2.TestAllTypes.RepeatedGroup} */ (this.get$ValueOrDefault(46, index));
2028
};
2029

2030

2031
/**
2032
 * Adds a value to the repeatedgroup field.
2033
 * @param {!proto2.TestAllTypes.RepeatedGroup} value The value to add.
2034
 */
2035
proto2.TestAllTypes.prototype.addRepeatedgroup = function(value) {
2036
  this.add$Value(46, value);
2037
};
2038

2039

2040
/**
2041
 * Returns the array of values in the repeatedgroup field.
2042
 * @return {!Array<!proto2.TestAllTypes.RepeatedGroup>} The values in the field.
2043
 */
2044
proto2.TestAllTypes.prototype.repeatedgroupArray = function() {
2045
  return /** @type {!Array<!proto2.TestAllTypes.RepeatedGroup>} */ (this.array$Values(46));
2046
};
2047

2048

2049
/**
2050
 * @return {boolean} Whether the repeatedgroup field has a value.
2051
 */
2052
proto2.TestAllTypes.prototype.hasRepeatedgroup = function() {
2053
  return this.has$Value(46);
2054
};
2055

2056

2057
/**
2058
 * @return {number} The number of values in the repeatedgroup field.
2059
 */
2060
proto2.TestAllTypes.prototype.repeatedgroupCount = function() {
2061
  return this.count$Values(46);
2062
};
2063

2064

2065
/**
2066
 * Clears the values in the repeatedgroup field.
2067
 */
2068
proto2.TestAllTypes.prototype.clearRepeatedgroup = function() {
2069
  this.clear$Field(46);
2070
};
2071

2072

2073
/**
2074
 * Gets the value of the repeated_nested_message field at the index given.
2075
 * @param {number} index The index to lookup.
2076
 * @return {?proto2.TestAllTypes.NestedMessage} The value.
2077
 */
2078
proto2.TestAllTypes.prototype.getRepeatedNestedMessage = function(index) {
2079
  return /** @type {?proto2.TestAllTypes.NestedMessage} */ (this.get$Value(48, index));
2080
};
2081

2082

2083
/**
2084
 * Gets the value of the repeated_nested_message field at the index given or the default value if not set.
2085
 * @param {number} index The index to lookup.
2086
 * @return {!proto2.TestAllTypes.NestedMessage} The value.
2087
 */
2088
proto2.TestAllTypes.prototype.getRepeatedNestedMessageOrDefault = function(index) {
2089
  return /** @type {!proto2.TestAllTypes.NestedMessage} */ (this.get$ValueOrDefault(48, index));
2090
};
2091

2092

2093
/**
2094
 * Adds a value to the repeated_nested_message field.
2095
 * @param {!proto2.TestAllTypes.NestedMessage} value The value to add.
2096
 */
2097
proto2.TestAllTypes.prototype.addRepeatedNestedMessage = function(value) {
2098
  this.add$Value(48, value);
2099
};
2100

2101

2102
/**
2103
 * Returns the array of values in the repeated_nested_message field.
2104
 * @return {!Array<!proto2.TestAllTypes.NestedMessage>} The values in the field.
2105
 */
2106
proto2.TestAllTypes.prototype.repeatedNestedMessageArray = function() {
2107
  return /** @type {!Array<!proto2.TestAllTypes.NestedMessage>} */ (this.array$Values(48));
2108
};
2109

2110

2111
/**
2112
 * @return {boolean} Whether the repeated_nested_message field has a value.
2113
 */
2114
proto2.TestAllTypes.prototype.hasRepeatedNestedMessage = function() {
2115
  return this.has$Value(48);
2116
};
2117

2118

2119
/**
2120
 * @return {number} The number of values in the repeated_nested_message field.
2121
 */
2122
proto2.TestAllTypes.prototype.repeatedNestedMessageCount = function() {
2123
  return this.count$Values(48);
2124
};
2125

2126

2127
/**
2128
 * Clears the values in the repeated_nested_message field.
2129
 */
2130
proto2.TestAllTypes.prototype.clearRepeatedNestedMessage = function() {
2131
  this.clear$Field(48);
2132
};
2133

2134

2135
/**
2136
 * Gets the value of the repeated_nested_enum field at the index given.
2137
 * @param {number} index The index to lookup.
2138
 * @return {?proto2.TestAllTypes.NestedEnum} The value.
2139
 */
2140
proto2.TestAllTypes.prototype.getRepeatedNestedEnum = function(index) {
2141
  return /** @type {?proto2.TestAllTypes.NestedEnum} */ (this.get$Value(49, index));
2142
};
2143

2144

2145
/**
2146
 * Gets the value of the repeated_nested_enum field at the index given or the default value if not set.
2147
 * @param {number} index The index to lookup.
2148
 * @return {!proto2.TestAllTypes.NestedEnum} The value.
2149
 */
2150
proto2.TestAllTypes.prototype.getRepeatedNestedEnumOrDefault = function(index) {
2151
  return /** @type {!proto2.TestAllTypes.NestedEnum} */ (this.get$ValueOrDefault(49, index));
2152
};
2153

2154

2155
/**
2156
 * Adds a value to the repeated_nested_enum field.
2157
 * @param {!proto2.TestAllTypes.NestedEnum} value The value to add.
2158
 */
2159
proto2.TestAllTypes.prototype.addRepeatedNestedEnum = function(value) {
2160
  this.add$Value(49, value);
2161
};
2162

2163

2164
/**
2165
 * Returns the array of values in the repeated_nested_enum field.
2166
 * @return {!Array<!proto2.TestAllTypes.NestedEnum>} The values in the field.
2167
 */
2168
proto2.TestAllTypes.prototype.repeatedNestedEnumArray = function() {
2169
  return /** @type {!Array<!proto2.TestAllTypes.NestedEnum>} */ (this.array$Values(49));
2170
};
2171

2172

2173
/**
2174
 * @return {boolean} Whether the repeated_nested_enum field has a value.
2175
 */
2176
proto2.TestAllTypes.prototype.hasRepeatedNestedEnum = function() {
2177
  return this.has$Value(49);
2178
};
2179

2180

2181
/**
2182
 * @return {number} The number of values in the repeated_nested_enum field.
2183
 */
2184
proto2.TestAllTypes.prototype.repeatedNestedEnumCount = function() {
2185
  return this.count$Values(49);
2186
};
2187

2188

2189
/**
2190
 * Clears the values in the repeated_nested_enum field.
2191
 */
2192
proto2.TestAllTypes.prototype.clearRepeatedNestedEnum = function() {
2193
  this.clear$Field(49);
2194
};
2195

2196

2197
/**
2198
 * Gets the value of the repeated_int64_number field at the index given.
2199
 * @param {number} index The index to lookup.
2200
 * @return {?number} The value.
2201
 */
2202
proto2.TestAllTypes.prototype.getRepeatedInt64Number = function(index) {
2203
  return /** @type {?number} */ (this.get$Value(52, index));
2204
};
2205

2206

2207
/**
2208
 * Gets the value of the repeated_int64_number field at the index given or the default value if not set.
2209
 * @param {number} index The index to lookup.
2210
 * @return {number} The value.
2211
 */
2212
proto2.TestAllTypes.prototype.getRepeatedInt64NumberOrDefault = function(index) {
2213
  return /** @type {number} */ (this.get$ValueOrDefault(52, index));
2214
};
2215

2216

2217
/**
2218
 * Adds a value to the repeated_int64_number field.
2219
 * @param {number} value The value to add.
2220
 */
2221
proto2.TestAllTypes.prototype.addRepeatedInt64Number = function(value) {
2222
  this.add$Value(52, value);
2223
};
2224

2225

2226
/**
2227
 * Returns the array of values in the repeated_int64_number field.
2228
 * @return {!Array<number>} The values in the field.
2229
 */
2230
proto2.TestAllTypes.prototype.repeatedInt64NumberArray = function() {
2231
  return /** @type {!Array<number>} */ (this.array$Values(52));
2232
};
2233

2234

2235
/**
2236
 * @return {boolean} Whether the repeated_int64_number field has a value.
2237
 */
2238
proto2.TestAllTypes.prototype.hasRepeatedInt64Number = function() {
2239
  return this.has$Value(52);
2240
};
2241

2242

2243
/**
2244
 * @return {number} The number of values in the repeated_int64_number field.
2245
 */
2246
proto2.TestAllTypes.prototype.repeatedInt64NumberCount = function() {
2247
  return this.count$Values(52);
2248
};
2249

2250

2251
/**
2252
 * Clears the values in the repeated_int64_number field.
2253
 */
2254
proto2.TestAllTypes.prototype.clearRepeatedInt64Number = function() {
2255
  this.clear$Field(52);
2256
};
2257

2258

2259
/**
2260
 * Gets the value of the repeated_int64_string field at the index given.
2261
 * @param {number} index The index to lookup.
2262
 * @return {?string} The value.
2263
 */
2264
proto2.TestAllTypes.prototype.getRepeatedInt64String = function(index) {
2265
  return /** @type {?string} */ (this.get$Value(53, index));
2266
};
2267

2268

2269
/**
2270
 * Gets the value of the repeated_int64_string field at the index given or the default value if not set.
2271
 * @param {number} index The index to lookup.
2272
 * @return {string} The value.
2273
 */
2274
proto2.TestAllTypes.prototype.getRepeatedInt64StringOrDefault = function(index) {
2275
  return /** @type {string} */ (this.get$ValueOrDefault(53, index));
2276
};
2277

2278

2279
/**
2280
 * Adds a value to the repeated_int64_string field.
2281
 * @param {string} value The value to add.
2282
 */
2283
proto2.TestAllTypes.prototype.addRepeatedInt64String = function(value) {
2284
  this.add$Value(53, value);
2285
};
2286

2287

2288
/**
2289
 * Returns the array of values in the repeated_int64_string field.
2290
 * @return {!Array<string>} The values in the field.
2291
 */
2292
proto2.TestAllTypes.prototype.repeatedInt64StringArray = function() {
2293
  return /** @type {!Array<string>} */ (this.array$Values(53));
2294
};
2295

2296

2297
/**
2298
 * @return {boolean} Whether the repeated_int64_string field has a value.
2299
 */
2300
proto2.TestAllTypes.prototype.hasRepeatedInt64String = function() {
2301
  return this.has$Value(53);
2302
};
2303

2304

2305
/**
2306
 * @return {number} The number of values in the repeated_int64_string field.
2307
 */
2308
proto2.TestAllTypes.prototype.repeatedInt64StringCount = function() {
2309
  return this.count$Values(53);
2310
};
2311

2312

2313
/**
2314
 * Clears the values in the repeated_int64_string field.
2315
 */
2316
proto2.TestAllTypes.prototype.clearRepeatedInt64String = function() {
2317
  this.clear$Field(53);
2318
};
2319

2320

2321
/**
2322
 * Gets the value of the packed_int32 field at the index given.
2323
 * @param {number} index The index to lookup.
2324
 * @return {?number} The value.
2325
 */
2326
proto2.TestAllTypes.prototype.getPackedInt32 = function(index) {
2327
  return /** @type {?number} */ (this.get$Value(54, index));
2328
};
2329

2330

2331
/**
2332
 * Gets the value of the packed_int32 field at the index given or the default value if not set.
2333
 * @param {number} index The index to lookup.
2334
 * @return {number} The value.
2335
 */
2336
proto2.TestAllTypes.prototype.getPackedInt32OrDefault = function(index) {
2337
  return /** @type {number} */ (this.get$ValueOrDefault(54, index));
2338
};
2339

2340

2341
/**
2342
 * Adds a value to the packed_int32 field.
2343
 * @param {number} value The value to add.
2344
 */
2345
proto2.TestAllTypes.prototype.addPackedInt32 = function(value) {
2346
  this.add$Value(54, value);
2347
};
2348

2349

2350
/**
2351
 * Returns the array of values in the packed_int32 field.
2352
 * @return {!Array<number>} The values in the field.
2353
 */
2354
proto2.TestAllTypes.prototype.packedInt32Array = function() {
2355
  return /** @type {!Array<number>} */ (this.array$Values(54));
2356
};
2357

2358

2359
/**
2360
 * @return {boolean} Whether the packed_int32 field has a value.
2361
 */
2362
proto2.TestAllTypes.prototype.hasPackedInt32 = function() {
2363
  return this.has$Value(54);
2364
};
2365

2366

2367
/**
2368
 * @return {number} The number of values in the packed_int32 field.
2369
 */
2370
proto2.TestAllTypes.prototype.packedInt32Count = function() {
2371
  return this.count$Values(54);
2372
};
2373

2374

2375
/**
2376
 * Clears the values in the packed_int32 field.
2377
 */
2378
proto2.TestAllTypes.prototype.clearPackedInt32 = function() {
2379
  this.clear$Field(54);
2380
};
2381

2382

2383
/**
2384
 * Gets the value of the packed_int64 field at the index given.
2385
 * @param {number} index The index to lookup.
2386
 * @return {?number} The value.
2387
 */
2388
proto2.TestAllTypes.prototype.getPackedInt64 = function(index) {
2389
  return /** @type {?number} */ (this.get$Value(55, index));
2390
};
2391

2392

2393
/**
2394
 * Gets the value of the packed_int64 field at the index given or the default value if not set.
2395
 * @param {number} index The index to lookup.
2396
 * @return {number} The value.
2397
 */
2398
proto2.TestAllTypes.prototype.getPackedInt64OrDefault = function(index) {
2399
  return /** @type {number} */ (this.get$ValueOrDefault(55, index));
2400
};
2401

2402

2403
/**
2404
 * Adds a value to the packed_int64 field.
2405
 * @param {number} value The value to add.
2406
 */
2407
proto2.TestAllTypes.prototype.addPackedInt64 = function(value) {
2408
  this.add$Value(55, value);
2409
};
2410

2411

2412
/**
2413
 * Returns the array of values in the packed_int64 field.
2414
 * @return {!Array<number>} The values in the field.
2415
 */
2416
proto2.TestAllTypes.prototype.packedInt64Array = function() {
2417
  return /** @type {!Array<number>} */ (this.array$Values(55));
2418
};
2419

2420

2421
/**
2422
 * @return {boolean} Whether the packed_int64 field has a value.
2423
 */
2424
proto2.TestAllTypes.prototype.hasPackedInt64 = function() {
2425
  return this.has$Value(55);
2426
};
2427

2428

2429
/**
2430
 * @return {number} The number of values in the packed_int64 field.
2431
 */
2432
proto2.TestAllTypes.prototype.packedInt64Count = function() {
2433
  return this.count$Values(55);
2434
};
2435

2436

2437
/**
2438
 * Clears the values in the packed_int64 field.
2439
 */
2440
proto2.TestAllTypes.prototype.clearPackedInt64 = function() {
2441
  this.clear$Field(55);
2442
};
2443

2444

2445
/**
2446
 * Gets the value of the packed_uint32 field at the index given.
2447
 * @param {number} index The index to lookup.
2448
 * @return {?number} The value.
2449
 */
2450
proto2.TestAllTypes.prototype.getPackedUint32 = function(index) {
2451
  return /** @type {?number} */ (this.get$Value(56, index));
2452
};
2453

2454

2455
/**
2456
 * Gets the value of the packed_uint32 field at the index given or the default value if not set.
2457
 * @param {number} index The index to lookup.
2458
 * @return {number} The value.
2459
 */
2460
proto2.TestAllTypes.prototype.getPackedUint32OrDefault = function(index) {
2461
  return /** @type {number} */ (this.get$ValueOrDefault(56, index));
2462
};
2463

2464

2465
/**
2466
 * Adds a value to the packed_uint32 field.
2467
 * @param {number} value The value to add.
2468
 */
2469
proto2.TestAllTypes.prototype.addPackedUint32 = function(value) {
2470
  this.add$Value(56, value);
2471
};
2472

2473

2474
/**
2475
 * Returns the array of values in the packed_uint32 field.
2476
 * @return {!Array<number>} The values in the field.
2477
 */
2478
proto2.TestAllTypes.prototype.packedUint32Array = function() {
2479
  return /** @type {!Array<number>} */ (this.array$Values(56));
2480
};
2481

2482

2483
/**
2484
 * @return {boolean} Whether the packed_uint32 field has a value.
2485
 */
2486
proto2.TestAllTypes.prototype.hasPackedUint32 = function() {
2487
  return this.has$Value(56);
2488
};
2489

2490

2491
/**
2492
 * @return {number} The number of values in the packed_uint32 field.
2493
 */
2494
proto2.TestAllTypes.prototype.packedUint32Count = function() {
2495
  return this.count$Values(56);
2496
};
2497

2498

2499
/**
2500
 * Clears the values in the packed_uint32 field.
2501
 */
2502
proto2.TestAllTypes.prototype.clearPackedUint32 = function() {
2503
  this.clear$Field(56);
2504
};
2505

2506

2507
/**
2508
 * Gets the value of the packed_uint64 field at the index given.
2509
 * @param {number} index The index to lookup.
2510
 * @return {?number} The value.
2511
 */
2512
proto2.TestAllTypes.prototype.getPackedUint64 = function(index) {
2513
  return /** @type {?number} */ (this.get$Value(57, index));
2514
};
2515

2516

2517
/**
2518
 * Gets the value of the packed_uint64 field at the index given or the default value if not set.
2519
 * @param {number} index The index to lookup.
2520
 * @return {number} The value.
2521
 */
2522
proto2.TestAllTypes.prototype.getPackedUint64OrDefault = function(index) {
2523
  return /** @type {number} */ (this.get$ValueOrDefault(57, index));
2524
};
2525

2526

2527
/**
2528
 * Adds a value to the packed_uint64 field.
2529
 * @param {number} value The value to add.
2530
 */
2531
proto2.TestAllTypes.prototype.addPackedUint64 = function(value) {
2532
  this.add$Value(57, value);
2533
};
2534

2535

2536
/**
2537
 * Returns the array of values in the packed_uint64 field.
2538
 * @return {!Array<number>} The values in the field.
2539
 */
2540
proto2.TestAllTypes.prototype.packedUint64Array = function() {
2541
  return /** @type {!Array<number>} */ (this.array$Values(57));
2542
};
2543

2544

2545
/**
2546
 * @return {boolean} Whether the packed_uint64 field has a value.
2547
 */
2548
proto2.TestAllTypes.prototype.hasPackedUint64 = function() {
2549
  return this.has$Value(57);
2550
};
2551

2552

2553
/**
2554
 * @return {number} The number of values in the packed_uint64 field.
2555
 */
2556
proto2.TestAllTypes.prototype.packedUint64Count = function() {
2557
  return this.count$Values(57);
2558
};
2559

2560

2561
/**
2562
 * Clears the values in the packed_uint64 field.
2563
 */
2564
proto2.TestAllTypes.prototype.clearPackedUint64 = function() {
2565
  this.clear$Field(57);
2566
};
2567

2568

2569
/**
2570
 * Gets the value of the packed_sint32 field at the index given.
2571
 * @param {number} index The index to lookup.
2572
 * @return {?number} The value.
2573
 */
2574
proto2.TestAllTypes.prototype.getPackedSint32 = function(index) {
2575
  return /** @type {?number} */ (this.get$Value(58, index));
2576
};
2577

2578

2579
/**
2580
 * Gets the value of the packed_sint32 field at the index given or the default value if not set.
2581
 * @param {number} index The index to lookup.
2582
 * @return {number} The value.
2583
 */
2584
proto2.TestAllTypes.prototype.getPackedSint32OrDefault = function(index) {
2585
  return /** @type {number} */ (this.get$ValueOrDefault(58, index));
2586
};
2587

2588

2589
/**
2590
 * Adds a value to the packed_sint32 field.
2591
 * @param {number} value The value to add.
2592
 */
2593
proto2.TestAllTypes.prototype.addPackedSint32 = function(value) {
2594
  this.add$Value(58, value);
2595
};
2596

2597

2598
/**
2599
 * Returns the array of values in the packed_sint32 field.
2600
 * @return {!Array<number>} The values in the field.
2601
 */
2602
proto2.TestAllTypes.prototype.packedSint32Array = function() {
2603
  return /** @type {!Array<number>} */ (this.array$Values(58));
2604
};
2605

2606

2607
/**
2608
 * @return {boolean} Whether the packed_sint32 field has a value.
2609
 */
2610
proto2.TestAllTypes.prototype.hasPackedSint32 = function() {
2611
  return this.has$Value(58);
2612
};
2613

2614

2615
/**
2616
 * @return {number} The number of values in the packed_sint32 field.
2617
 */
2618
proto2.TestAllTypes.prototype.packedSint32Count = function() {
2619
  return this.count$Values(58);
2620
};
2621

2622

2623
/**
2624
 * Clears the values in the packed_sint32 field.
2625
 */
2626
proto2.TestAllTypes.prototype.clearPackedSint32 = function() {
2627
  this.clear$Field(58);
2628
};
2629

2630

2631
/**
2632
 * Gets the value of the packed_sint64 field at the index given.
2633
 * @param {number} index The index to lookup.
2634
 * @return {?number} The value.
2635
 */
2636
proto2.TestAllTypes.prototype.getPackedSint64 = function(index) {
2637
  return /** @type {?number} */ (this.get$Value(59, index));
2638
};
2639

2640

2641
/**
2642
 * Gets the value of the packed_sint64 field at the index given or the default value if not set.
2643
 * @param {number} index The index to lookup.
2644
 * @return {number} The value.
2645
 */
2646
proto2.TestAllTypes.prototype.getPackedSint64OrDefault = function(index) {
2647
  return /** @type {number} */ (this.get$ValueOrDefault(59, index));
2648
};
2649

2650

2651
/**
2652
 * Adds a value to the packed_sint64 field.
2653
 * @param {number} value The value to add.
2654
 */
2655
proto2.TestAllTypes.prototype.addPackedSint64 = function(value) {
2656
  this.add$Value(59, value);
2657
};
2658

2659

2660
/**
2661
 * Returns the array of values in the packed_sint64 field.
2662
 * @return {!Array<number>} The values in the field.
2663
 */
2664
proto2.TestAllTypes.prototype.packedSint64Array = function() {
2665
  return /** @type {!Array<number>} */ (this.array$Values(59));
2666
};
2667

2668

2669
/**
2670
 * @return {boolean} Whether the packed_sint64 field has a value.
2671
 */
2672
proto2.TestAllTypes.prototype.hasPackedSint64 = function() {
2673
  return this.has$Value(59);
2674
};
2675

2676

2677
/**
2678
 * @return {number} The number of values in the packed_sint64 field.
2679
 */
2680
proto2.TestAllTypes.prototype.packedSint64Count = function() {
2681
  return this.count$Values(59);
2682
};
2683

2684

2685
/**
2686
 * Clears the values in the packed_sint64 field.
2687
 */
2688
proto2.TestAllTypes.prototype.clearPackedSint64 = function() {
2689
  this.clear$Field(59);
2690
};
2691

2692

2693
/**
2694
 * Gets the value of the packed_fixed32 field at the index given.
2695
 * @param {number} index The index to lookup.
2696
 * @return {?number} The value.
2697
 */
2698
proto2.TestAllTypes.prototype.getPackedFixed32 = function(index) {
2699
  return /** @type {?number} */ (this.get$Value(60, index));
2700
};
2701

2702

2703
/**
2704
 * Gets the value of the packed_fixed32 field at the index given or the default value if not set.
2705
 * @param {number} index The index to lookup.
2706
 * @return {number} The value.
2707
 */
2708
proto2.TestAllTypes.prototype.getPackedFixed32OrDefault = function(index) {
2709
  return /** @type {number} */ (this.get$ValueOrDefault(60, index));
2710
};
2711

2712

2713
/**
2714
 * Adds a value to the packed_fixed32 field.
2715
 * @param {number} value The value to add.
2716
 */
2717
proto2.TestAllTypes.prototype.addPackedFixed32 = function(value) {
2718
  this.add$Value(60, value);
2719
};
2720

2721

2722
/**
2723
 * Returns the array of values in the packed_fixed32 field.
2724
 * @return {!Array<number>} The values in the field.
2725
 */
2726
proto2.TestAllTypes.prototype.packedFixed32Array = function() {
2727
  return /** @type {!Array<number>} */ (this.array$Values(60));
2728
};
2729

2730

2731
/**
2732
 * @return {boolean} Whether the packed_fixed32 field has a value.
2733
 */
2734
proto2.TestAllTypes.prototype.hasPackedFixed32 = function() {
2735
  return this.has$Value(60);
2736
};
2737

2738

2739
/**
2740
 * @return {number} The number of values in the packed_fixed32 field.
2741
 */
2742
proto2.TestAllTypes.prototype.packedFixed32Count = function() {
2743
  return this.count$Values(60);
2744
};
2745

2746

2747
/**
2748
 * Clears the values in the packed_fixed32 field.
2749
 */
2750
proto2.TestAllTypes.prototype.clearPackedFixed32 = function() {
2751
  this.clear$Field(60);
2752
};
2753

2754

2755
/**
2756
 * Gets the value of the packed_fixed64 field at the index given.
2757
 * @param {number} index The index to lookup.
2758
 * @return {?number} The value.
2759
 */
2760
proto2.TestAllTypes.prototype.getPackedFixed64 = function(index) {
2761
  return /** @type {?number} */ (this.get$Value(61, index));
2762
};
2763

2764

2765
/**
2766
 * Gets the value of the packed_fixed64 field at the index given or the default value if not set.
2767
 * @param {number} index The index to lookup.
2768
 * @return {number} The value.
2769
 */
2770
proto2.TestAllTypes.prototype.getPackedFixed64OrDefault = function(index) {
2771
  return /** @type {number} */ (this.get$ValueOrDefault(61, index));
2772
};
2773

2774

2775
/**
2776
 * Adds a value to the packed_fixed64 field.
2777
 * @param {number} value The value to add.
2778
 */
2779
proto2.TestAllTypes.prototype.addPackedFixed64 = function(value) {
2780
  this.add$Value(61, value);
2781
};
2782

2783

2784
/**
2785
 * Returns the array of values in the packed_fixed64 field.
2786
 * @return {!Array<number>} The values in the field.
2787
 */
2788
proto2.TestAllTypes.prototype.packedFixed64Array = function() {
2789
  return /** @type {!Array<number>} */ (this.array$Values(61));
2790
};
2791

2792

2793
/**
2794
 * @return {boolean} Whether the packed_fixed64 field has a value.
2795
 */
2796
proto2.TestAllTypes.prototype.hasPackedFixed64 = function() {
2797
  return this.has$Value(61);
2798
};
2799

2800

2801
/**
2802
 * @return {number} The number of values in the packed_fixed64 field.
2803
 */
2804
proto2.TestAllTypes.prototype.packedFixed64Count = function() {
2805
  return this.count$Values(61);
2806
};
2807

2808

2809
/**
2810
 * Clears the values in the packed_fixed64 field.
2811
 */
2812
proto2.TestAllTypes.prototype.clearPackedFixed64 = function() {
2813
  this.clear$Field(61);
2814
};
2815

2816

2817
/**
2818
 * Gets the value of the packed_sfixed32 field at the index given.
2819
 * @param {number} index The index to lookup.
2820
 * @return {?number} The value.
2821
 */
2822
proto2.TestAllTypes.prototype.getPackedSfixed32 = function(index) {
2823
  return /** @type {?number} */ (this.get$Value(62, index));
2824
};
2825

2826

2827
/**
2828
 * Gets the value of the packed_sfixed32 field at the index given or the default value if not set.
2829
 * @param {number} index The index to lookup.
2830
 * @return {number} The value.
2831
 */
2832
proto2.TestAllTypes.prototype.getPackedSfixed32OrDefault = function(index) {
2833
  return /** @type {number} */ (this.get$ValueOrDefault(62, index));
2834
};
2835

2836

2837
/**
2838
 * Adds a value to the packed_sfixed32 field.
2839
 * @param {number} value The value to add.
2840
 */
2841
proto2.TestAllTypes.prototype.addPackedSfixed32 = function(value) {
2842
  this.add$Value(62, value);
2843
};
2844

2845

2846
/**
2847
 * Returns the array of values in the packed_sfixed32 field.
2848
 * @return {!Array<number>} The values in the field.
2849
 */
2850
proto2.TestAllTypes.prototype.packedSfixed32Array = function() {
2851
  return /** @type {!Array<number>} */ (this.array$Values(62));
2852
};
2853

2854

2855
/**
2856
 * @return {boolean} Whether the packed_sfixed32 field has a value.
2857
 */
2858
proto2.TestAllTypes.prototype.hasPackedSfixed32 = function() {
2859
  return this.has$Value(62);
2860
};
2861

2862

2863
/**
2864
 * @return {number} The number of values in the packed_sfixed32 field.
2865
 */
2866
proto2.TestAllTypes.prototype.packedSfixed32Count = function() {
2867
  return this.count$Values(62);
2868
};
2869

2870

2871
/**
2872
 * Clears the values in the packed_sfixed32 field.
2873
 */
2874
proto2.TestAllTypes.prototype.clearPackedSfixed32 = function() {
2875
  this.clear$Field(62);
2876
};
2877

2878

2879
/**
2880
 * Gets the value of the packed_sfixed64 field at the index given.
2881
 * @param {number} index The index to lookup.
2882
 * @return {?number} The value.
2883
 */
2884
proto2.TestAllTypes.prototype.getPackedSfixed64 = function(index) {
2885
  return /** @type {?number} */ (this.get$Value(63, index));
2886
};
2887

2888

2889
/**
2890
 * Gets the value of the packed_sfixed64 field at the index given or the default value if not set.
2891
 * @param {number} index The index to lookup.
2892
 * @return {number} The value.
2893
 */
2894
proto2.TestAllTypes.prototype.getPackedSfixed64OrDefault = function(index) {
2895
  return /** @type {number} */ (this.get$ValueOrDefault(63, index));
2896
};
2897

2898

2899
/**
2900
 * Adds a value to the packed_sfixed64 field.
2901
 * @param {number} value The value to add.
2902
 */
2903
proto2.TestAllTypes.prototype.addPackedSfixed64 = function(value) {
2904
  this.add$Value(63, value);
2905
};
2906

2907

2908
/**
2909
 * Returns the array of values in the packed_sfixed64 field.
2910
 * @return {!Array<number>} The values in the field.
2911
 */
2912
proto2.TestAllTypes.prototype.packedSfixed64Array = function() {
2913
  return /** @type {!Array<number>} */ (this.array$Values(63));
2914
};
2915

2916

2917
/**
2918
 * @return {boolean} Whether the packed_sfixed64 field has a value.
2919
 */
2920
proto2.TestAllTypes.prototype.hasPackedSfixed64 = function() {
2921
  return this.has$Value(63);
2922
};
2923

2924

2925
/**
2926
 * @return {number} The number of values in the packed_sfixed64 field.
2927
 */
2928
proto2.TestAllTypes.prototype.packedSfixed64Count = function() {
2929
  return this.count$Values(63);
2930
};
2931

2932

2933
/**
2934
 * Clears the values in the packed_sfixed64 field.
2935
 */
2936
proto2.TestAllTypes.prototype.clearPackedSfixed64 = function() {
2937
  this.clear$Field(63);
2938
};
2939

2940

2941
/**
2942
 * Gets the value of the packed_float field at the index given.
2943
 * @param {number} index The index to lookup.
2944
 * @return {?number} The value.
2945
 */
2946
proto2.TestAllTypes.prototype.getPackedFloat = function(index) {
2947
  return /** @type {?number} */ (this.get$Value(64, index));
2948
};
2949

2950

2951
/**
2952
 * Gets the value of the packed_float field at the index given or the default value if not set.
2953
 * @param {number} index The index to lookup.
2954
 * @return {number} The value.
2955
 */
2956
proto2.TestAllTypes.prototype.getPackedFloatOrDefault = function(index) {
2957
  return /** @type {number} */ (this.get$ValueOrDefault(64, index));
2958
};
2959

2960

2961
/**
2962
 * Adds a value to the packed_float field.
2963
 * @param {number} value The value to add.
2964
 */
2965
proto2.TestAllTypes.prototype.addPackedFloat = function(value) {
2966
  this.add$Value(64, value);
2967
};
2968

2969

2970
/**
2971
 * Returns the array of values in the packed_float field.
2972
 * @return {!Array<number>} The values in the field.
2973
 */
2974
proto2.TestAllTypes.prototype.packedFloatArray = function() {
2975
  return /** @type {!Array<number>} */ (this.array$Values(64));
2976
};
2977

2978

2979
/**
2980
 * @return {boolean} Whether the packed_float field has a value.
2981
 */
2982
proto2.TestAllTypes.prototype.hasPackedFloat = function() {
2983
  return this.has$Value(64);
2984
};
2985

2986

2987
/**
2988
 * @return {number} The number of values in the packed_float field.
2989
 */
2990
proto2.TestAllTypes.prototype.packedFloatCount = function() {
2991
  return this.count$Values(64);
2992
};
2993

2994

2995
/**
2996
 * Clears the values in the packed_float field.
2997
 */
2998
proto2.TestAllTypes.prototype.clearPackedFloat = function() {
2999
  this.clear$Field(64);
3000
};
3001

3002

3003
/**
3004
 * Gets the value of the packed_double field at the index given.
3005
 * @param {number} index The index to lookup.
3006
 * @return {?number} The value.
3007
 */
3008
proto2.TestAllTypes.prototype.getPackedDouble = function(index) {
3009
  return /** @type {?number} */ (this.get$Value(65, index));
3010
};
3011

3012

3013
/**
3014
 * Gets the value of the packed_double field at the index given or the default value if not set.
3015
 * @param {number} index The index to lookup.
3016
 * @return {number} The value.
3017
 */
3018
proto2.TestAllTypes.prototype.getPackedDoubleOrDefault = function(index) {
3019
  return /** @type {number} */ (this.get$ValueOrDefault(65, index));
3020
};
3021

3022

3023
/**
3024
 * Adds a value to the packed_double field.
3025
 * @param {number} value The value to add.
3026
 */
3027
proto2.TestAllTypes.prototype.addPackedDouble = function(value) {
3028
  this.add$Value(65, value);
3029
};
3030

3031

3032
/**
3033
 * Returns the array of values in the packed_double field.
3034
 * @return {!Array<number>} The values in the field.
3035
 */
3036
proto2.TestAllTypes.prototype.packedDoubleArray = function() {
3037
  return /** @type {!Array<number>} */ (this.array$Values(65));
3038
};
3039

3040

3041
/**
3042
 * @return {boolean} Whether the packed_double field has a value.
3043
 */
3044
proto2.TestAllTypes.prototype.hasPackedDouble = function() {
3045
  return this.has$Value(65);
3046
};
3047

3048

3049
/**
3050
 * @return {number} The number of values in the packed_double field.
3051
 */
3052
proto2.TestAllTypes.prototype.packedDoubleCount = function() {
3053
  return this.count$Values(65);
3054
};
3055

3056

3057
/**
3058
 * Clears the values in the packed_double field.
3059
 */
3060
proto2.TestAllTypes.prototype.clearPackedDouble = function() {
3061
  this.clear$Field(65);
3062
};
3063

3064

3065
/**
3066
 * Gets the value of the packed_bool field at the index given.
3067
 * @param {number} index The index to lookup.
3068
 * @return {?boolean} The value.
3069
 */
3070
proto2.TestAllTypes.prototype.getPackedBool = function(index) {
3071
  return /** @type {?boolean} */ (this.get$Value(66, index));
3072
};
3073

3074

3075
/**
3076
 * Gets the value of the packed_bool field at the index given or the default value if not set.
3077
 * @param {number} index The index to lookup.
3078
 * @return {boolean} The value.
3079
 */
3080
proto2.TestAllTypes.prototype.getPackedBoolOrDefault = function(index) {
3081
  return /** @type {boolean} */ (this.get$ValueOrDefault(66, index));
3082
};
3083

3084

3085
/**
3086
 * Adds a value to the packed_bool field.
3087
 * @param {boolean} value The value to add.
3088
 */
3089
proto2.TestAllTypes.prototype.addPackedBool = function(value) {
3090
  this.add$Value(66, value);
3091
};
3092

3093

3094
/**
3095
 * Returns the array of values in the packed_bool field.
3096
 * @return {!Array<boolean>} The values in the field.
3097
 */
3098
proto2.TestAllTypes.prototype.packedBoolArray = function() {
3099
  return /** @type {!Array<boolean>} */ (this.array$Values(66));
3100
};
3101

3102

3103
/**
3104
 * @return {boolean} Whether the packed_bool field has a value.
3105
 */
3106
proto2.TestAllTypes.prototype.hasPackedBool = function() {
3107
  return this.has$Value(66);
3108
};
3109

3110

3111
/**
3112
 * @return {number} The number of values in the packed_bool field.
3113
 */
3114
proto2.TestAllTypes.prototype.packedBoolCount = function() {
3115
  return this.count$Values(66);
3116
};
3117

3118

3119
/**
3120
 * Clears the values in the packed_bool field.
3121
 */
3122
proto2.TestAllTypes.prototype.clearPackedBool = function() {
3123
  this.clear$Field(66);
3124
};
3125

3126

3127
/**
3128
 * Enumeration NestedEnum.
3129
 * @enum {number}
3130
 */
3131
proto2.TestAllTypes.NestedEnum = {
3132
  FOO: 0,
3133
  OOF: 1,
3134
  BAR: 2,
3135
  BAZ: 3
3136
};
3137

3138

3139

3140
/**
3141
 * Message NestedMessage.
3142
 * @constructor
3143
 * @extends {goog.proto2.Message}
3144
 * @final
3145
 */
3146
proto2.TestAllTypes.NestedMessage = function() {
3147
  goog.proto2.Message.call(this);
3148
};
3149
goog.inherits(proto2.TestAllTypes.NestedMessage, goog.proto2.Message);
3150

3151

3152
/**
3153
 * Descriptor for this message, deserialized lazily in getDescriptor().
3154
 * @private {?goog.proto2.Descriptor}
3155
 */
3156
proto2.TestAllTypes.NestedMessage.descriptor_ = null;
3157

3158

3159
/**
3160
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3161
 * @return {!proto2.TestAllTypes.NestedMessage} The cloned message.
3162
 * @override
3163
 */
3164
proto2.TestAllTypes.NestedMessage.prototype.clone;
3165

3166

3167
/**
3168
 * Gets the value of the b field.
3169
 * @return {?number} The value.
3170
 */
3171
proto2.TestAllTypes.NestedMessage.prototype.getB = function() {
3172
  return /** @type {?number} */ (this.get$Value(1));
3173
};
3174

3175

3176
/**
3177
 * Gets the value of the b field or the default value if not set.
3178
 * @return {number} The value.
3179
 */
3180
proto2.TestAllTypes.NestedMessage.prototype.getBOrDefault = function() {
3181
  return /** @type {number} */ (this.get$ValueOrDefault(1));
3182
};
3183

3184

3185
/**
3186
 * Sets the value of the b field.
3187
 * @param {number} value The value.
3188
 */
3189
proto2.TestAllTypes.NestedMessage.prototype.setB = function(value) {
3190
  this.set$Value(1, value);
3191
};
3192

3193

3194
/**
3195
 * @return {boolean} Whether the b field has a value.
3196
 */
3197
proto2.TestAllTypes.NestedMessage.prototype.hasB = function() {
3198
  return this.has$Value(1);
3199
};
3200

3201

3202
/**
3203
 * @return {number} The number of values in the b field.
3204
 */
3205
proto2.TestAllTypes.NestedMessage.prototype.bCount = function() {
3206
  return this.count$Values(1);
3207
};
3208

3209

3210
/**
3211
 * Clears the values in the b field.
3212
 */
3213
proto2.TestAllTypes.NestedMessage.prototype.clearB = function() {
3214
  this.clear$Field(1);
3215
};
3216

3217

3218
/**
3219
 * Gets the value of the c field.
3220
 * @return {?number} The value.
3221
 */
3222
proto2.TestAllTypes.NestedMessage.prototype.getC = function() {
3223
  return /** @type {?number} */ (this.get$Value(2));
3224
};
3225

3226

3227
/**
3228
 * Gets the value of the c field or the default value if not set.
3229
 * @return {number} The value.
3230
 */
3231
proto2.TestAllTypes.NestedMessage.prototype.getCOrDefault = function() {
3232
  return /** @type {number} */ (this.get$ValueOrDefault(2));
3233
};
3234

3235

3236
/**
3237
 * Sets the value of the c field.
3238
 * @param {number} value The value.
3239
 */
3240
proto2.TestAllTypes.NestedMessage.prototype.setC = function(value) {
3241
  this.set$Value(2, value);
3242
};
3243

3244

3245
/**
3246
 * @return {boolean} Whether the c field has a value.
3247
 */
3248
proto2.TestAllTypes.NestedMessage.prototype.hasC = function() {
3249
  return this.has$Value(2);
3250
};
3251

3252

3253
/**
3254
 * @return {number} The number of values in the c field.
3255
 */
3256
proto2.TestAllTypes.NestedMessage.prototype.cCount = function() {
3257
  return this.count$Values(2);
3258
};
3259

3260

3261
/**
3262
 * Clears the values in the c field.
3263
 */
3264
proto2.TestAllTypes.NestedMessage.prototype.clearC = function() {
3265
  this.clear$Field(2);
3266
};
3267

3268

3269

3270
/**
3271
 * Message OptionalGroup.
3272
 * @constructor
3273
 * @extends {goog.proto2.Message}
3274
 * @final
3275
 */
3276
proto2.TestAllTypes.OptionalGroup = function() {
3277
  goog.proto2.Message.call(this);
3278
};
3279
goog.inherits(proto2.TestAllTypes.OptionalGroup, goog.proto2.Message);
3280

3281

3282
/**
3283
 * Descriptor for this message, deserialized lazily in getDescriptor().
3284
 * @private {?goog.proto2.Descriptor}
3285
 */
3286
proto2.TestAllTypes.OptionalGroup.descriptor_ = null;
3287

3288

3289
/**
3290
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3291
 * @return {!proto2.TestAllTypes.OptionalGroup} The cloned message.
3292
 * @override
3293
 */
3294
proto2.TestAllTypes.OptionalGroup.prototype.clone;
3295

3296

3297
/**
3298
 * Gets the value of the a field.
3299
 * @return {?number} The value.
3300
 */
3301
proto2.TestAllTypes.OptionalGroup.prototype.getA = function() {
3302
  return /** @type {?number} */ (this.get$Value(17));
3303
};
3304

3305

3306
/**
3307
 * Gets the value of the a field or the default value if not set.
3308
 * @return {number} The value.
3309
 */
3310
proto2.TestAllTypes.OptionalGroup.prototype.getAOrDefault = function() {
3311
  return /** @type {number} */ (this.get$ValueOrDefault(17));
3312
};
3313

3314

3315
/**
3316
 * Sets the value of the a field.
3317
 * @param {number} value The value.
3318
 */
3319
proto2.TestAllTypes.OptionalGroup.prototype.setA = function(value) {
3320
  this.set$Value(17, value);
3321
};
3322

3323

3324
/**
3325
 * @return {boolean} Whether the a field has a value.
3326
 */
3327
proto2.TestAllTypes.OptionalGroup.prototype.hasA = function() {
3328
  return this.has$Value(17);
3329
};
3330

3331

3332
/**
3333
 * @return {number} The number of values in the a field.
3334
 */
3335
proto2.TestAllTypes.OptionalGroup.prototype.aCount = function() {
3336
  return this.count$Values(17);
3337
};
3338

3339

3340
/**
3341
 * Clears the values in the a field.
3342
 */
3343
proto2.TestAllTypes.OptionalGroup.prototype.clearA = function() {
3344
  this.clear$Field(17);
3345
};
3346

3347

3348

3349
/**
3350
 * Message RepeatedGroup.
3351
 * @constructor
3352
 * @extends {goog.proto2.Message}
3353
 * @final
3354
 */
3355
proto2.TestAllTypes.RepeatedGroup = function() {
3356
  goog.proto2.Message.call(this);
3357
};
3358
goog.inherits(proto2.TestAllTypes.RepeatedGroup, goog.proto2.Message);
3359

3360

3361
/**
3362
 * Descriptor for this message, deserialized lazily in getDescriptor().
3363
 * @private {?goog.proto2.Descriptor}
3364
 */
3365
proto2.TestAllTypes.RepeatedGroup.descriptor_ = null;
3366

3367

3368
/**
3369
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3370
 * @return {!proto2.TestAllTypes.RepeatedGroup} The cloned message.
3371
 * @override
3372
 */
3373
proto2.TestAllTypes.RepeatedGroup.prototype.clone;
3374

3375

3376
/**
3377
 * Gets the value of the a field at the index given.
3378
 * @param {number} index The index to lookup.
3379
 * @return {?number} The value.
3380
 */
3381
proto2.TestAllTypes.RepeatedGroup.prototype.getA = function(index) {
3382
  return /** @type {?number} */ (this.get$Value(47, index));
3383
};
3384

3385

3386
/**
3387
 * Gets the value of the a field at the index given or the default value if not set.
3388
 * @param {number} index The index to lookup.
3389
 * @return {number} The value.
3390
 */
3391
proto2.TestAllTypes.RepeatedGroup.prototype.getAOrDefault = function(index) {
3392
  return /** @type {number} */ (this.get$ValueOrDefault(47, index));
3393
};
3394

3395

3396
/**
3397
 * Adds a value to the a field.
3398
 * @param {number} value The value to add.
3399
 */
3400
proto2.TestAllTypes.RepeatedGroup.prototype.addA = function(value) {
3401
  this.add$Value(47, value);
3402
};
3403

3404

3405
/**
3406
 * Returns the array of values in the a field.
3407
 * @return {!Array<number>} The values in the field.
3408
 */
3409
proto2.TestAllTypes.RepeatedGroup.prototype.aArray = function() {
3410
  return /** @type {!Array<number>} */ (this.array$Values(47));
3411
};
3412

3413

3414
/**
3415
 * @return {boolean} Whether the a field has a value.
3416
 */
3417
proto2.TestAllTypes.RepeatedGroup.prototype.hasA = function() {
3418
  return this.has$Value(47);
3419
};
3420

3421

3422
/**
3423
 * @return {number} The number of values in the a field.
3424
 */
3425
proto2.TestAllTypes.RepeatedGroup.prototype.aCount = function() {
3426
  return this.count$Values(47);
3427
};
3428

3429

3430
/**
3431
 * Clears the values in the a field.
3432
 */
3433
proto2.TestAllTypes.RepeatedGroup.prototype.clearA = function() {
3434
  this.clear$Field(47);
3435
};
3436

3437

3438

3439
/**
3440
 * Message TestDefaultParent.
3441
 * @constructor
3442
 * @extends {goog.proto2.Message}
3443
 * @final
3444
 */
3445
proto2.TestDefaultParent = function() {
3446
  goog.proto2.Message.call(this);
3447
};
3448
goog.inherits(proto2.TestDefaultParent, goog.proto2.Message);
3449

3450

3451
/**
3452
 * Descriptor for this message, deserialized lazily in getDescriptor().
3453
 * @private {?goog.proto2.Descriptor}
3454
 */
3455
proto2.TestDefaultParent.descriptor_ = null;
3456

3457

3458
/**
3459
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3460
 * @return {!proto2.TestDefaultParent} The cloned message.
3461
 * @override
3462
 */
3463
proto2.TestDefaultParent.prototype.clone;
3464

3465

3466
/**
3467
 * Gets the value of the child field.
3468
 * @return {?proto2.TestDefaultChild} The value.
3469
 */
3470
proto2.TestDefaultParent.prototype.getChild = function() {
3471
  return /** @type {?proto2.TestDefaultChild} */ (this.get$Value(1));
3472
};
3473

3474

3475
/**
3476
 * Gets the value of the child field or the default value if not set.
3477
 * @return {!proto2.TestDefaultChild} The value.
3478
 */
3479
proto2.TestDefaultParent.prototype.getChildOrDefault = function() {
3480
  return /** @type {!proto2.TestDefaultChild} */ (this.get$ValueOrDefault(1));
3481
};
3482

3483

3484
/**
3485
 * Sets the value of the child field.
3486
 * @param {!proto2.TestDefaultChild} value The value.
3487
 */
3488
proto2.TestDefaultParent.prototype.setChild = function(value) {
3489
  this.set$Value(1, value);
3490
};
3491

3492

3493
/**
3494
 * @return {boolean} Whether the child field has a value.
3495
 */
3496
proto2.TestDefaultParent.prototype.hasChild = function() {
3497
  return this.has$Value(1);
3498
};
3499

3500

3501
/**
3502
 * @return {number} The number of values in the child field.
3503
 */
3504
proto2.TestDefaultParent.prototype.childCount = function() {
3505
  return this.count$Values(1);
3506
};
3507

3508

3509
/**
3510
 * Clears the values in the child field.
3511
 */
3512
proto2.TestDefaultParent.prototype.clearChild = function() {
3513
  this.clear$Field(1);
3514
};
3515

3516

3517

3518
/**
3519
 * Message TestDefaultChild.
3520
 * @constructor
3521
 * @extends {goog.proto2.Message}
3522
 * @final
3523
 */
3524
proto2.TestDefaultChild = function() {
3525
  goog.proto2.Message.call(this);
3526
};
3527
goog.inherits(proto2.TestDefaultChild, goog.proto2.Message);
3528

3529

3530
/**
3531
 * Descriptor for this message, deserialized lazily in getDescriptor().
3532
 * @private {?goog.proto2.Descriptor}
3533
 */
3534
proto2.TestDefaultChild.descriptor_ = null;
3535

3536

3537
/**
3538
 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3539
 * @return {!proto2.TestDefaultChild} The cloned message.
3540
 * @override
3541
 */
3542
proto2.TestDefaultChild.prototype.clone;
3543

3544

3545
/**
3546
 * Gets the value of the foo field.
3547
 * @return {?boolean} The value.
3548
 */
3549
proto2.TestDefaultChild.prototype.getFoo = function() {
3550
  return /** @type {?boolean} */ (this.get$Value(1));
3551
};
3552

3553

3554
/**
3555
 * Gets the value of the foo field or the default value if not set.
3556
 * @return {boolean} The value.
3557
 */
3558
proto2.TestDefaultChild.prototype.getFooOrDefault = function() {
3559
  return /** @type {boolean} */ (this.get$ValueOrDefault(1));
3560
};
3561

3562

3563
/**
3564
 * Sets the value of the foo field.
3565
 * @param {boolean} value The value.
3566
 */
3567
proto2.TestDefaultChild.prototype.setFoo = function(value) {
3568
  this.set$Value(1, value);
3569
};
3570

3571

3572
/**
3573
 * @return {boolean} Whether the foo field has a value.
3574
 */
3575
proto2.TestDefaultChild.prototype.hasFoo = function() {
3576
  return this.has$Value(1);
3577
};
3578

3579

3580
/**
3581
 * @return {number} The number of values in the foo field.
3582
 */
3583
proto2.TestDefaultChild.prototype.fooCount = function() {
3584
  return this.count$Values(1);
3585
};
3586

3587

3588
/**
3589
 * Clears the values in the foo field.
3590
 */
3591
proto2.TestDefaultChild.prototype.clearFoo = function() {
3592
  this.clear$Field(1);
3593
};
3594

3595

3596
/** @override */
3597
proto2.TestAllTypes.prototype.getDescriptor = function() {
3598
  var descriptor = proto2.TestAllTypes.descriptor_;
3599
  if (!descriptor) {
3600
    // The descriptor is created lazily when we instantiate a new instance.
3601
    var descriptorObj = {
3602
      0: {
3603
        name: 'TestAllTypes',
3604
        fullName: 'TestAllTypes'
3605
      },
3606
      1: {
3607
        name: 'optional_int32',
3608
        fieldType: goog.proto2.Message.FieldType.INT32,
3609
        type: Number
3610
      },
3611
      2: {
3612
        name: 'optional_int64',
3613
        fieldType: goog.proto2.Message.FieldType.INT64,
3614
        defaultValue: '1',
3615
        type: String
3616
      },
3617
      3: {
3618
        name: 'optional_uint32',
3619
        fieldType: goog.proto2.Message.FieldType.UINT32,
3620
        type: Number
3621
      },
3622
      4: {
3623
        name: 'optional_uint64',
3624
        fieldType: goog.proto2.Message.FieldType.UINT64,
3625
        type: String
3626
      },
3627
      5: {
3628
        name: 'optional_sint32',
3629
        fieldType: goog.proto2.Message.FieldType.SINT32,
3630
        type: Number
3631
      },
3632
      6: {
3633
        name: 'optional_sint64',
3634
        fieldType: goog.proto2.Message.FieldType.SINT64,
3635
        type: String
3636
      },
3637
      7: {
3638
        name: 'optional_fixed32',
3639
        fieldType: goog.proto2.Message.FieldType.FIXED32,
3640
        type: Number
3641
      },
3642
      8: {
3643
        name: 'optional_fixed64',
3644
        fieldType: goog.proto2.Message.FieldType.FIXED64,
3645
        type: String
3646
      },
3647
      9: {
3648
        name: 'optional_sfixed32',
3649
        fieldType: goog.proto2.Message.FieldType.SFIXED32,
3650
        type: Number
3651
      },
3652
      10: {
3653
        name: 'optional_sfixed64',
3654
        fieldType: goog.proto2.Message.FieldType.SFIXED64,
3655
        type: String
3656
      },
3657
      11: {
3658
        name: 'optional_float',
3659
        fieldType: goog.proto2.Message.FieldType.FLOAT,
3660
        defaultValue: 1.5,
3661
        type: Number
3662
      },
3663
      12: {
3664
        name: 'optional_double',
3665
        fieldType: goog.proto2.Message.FieldType.DOUBLE,
3666
        type: Number
3667
      },
3668
      13: {
3669
        name: 'optional_bool',
3670
        fieldType: goog.proto2.Message.FieldType.BOOL,
3671
        type: Boolean
3672
      },
3673
      14: {
3674
        name: 'optional_string',
3675
        fieldType: goog.proto2.Message.FieldType.STRING,
3676
        type: String
3677
      },
3678
      15: {
3679
        name: 'optional_bytes',
3680
        fieldType: goog.proto2.Message.FieldType.BYTES,
3681
        defaultValue: 'moo',
3682
        type: String
3683
      },
3684
      16: {
3685
        name: 'optionalgroup',
3686
        fieldType: goog.proto2.Message.FieldType.GROUP,
3687
        type: proto2.TestAllTypes.OptionalGroup
3688
      },
3689
      18: {
3690
        name: 'optional_nested_message',
3691
        fieldType: goog.proto2.Message.FieldType.MESSAGE,
3692
        type: proto2.TestAllTypes.NestedMessage
3693
      },
3694
      21: {
3695
        name: 'optional_nested_enum',
3696
        fieldType: goog.proto2.Message.FieldType.ENUM,
3697
        defaultValue: proto2.TestAllTypes.NestedEnum.FOO,
3698
        type: proto2.TestAllTypes.NestedEnum
3699
      },
3700
      50: {
3701
        name: 'optional_int64_number',
3702
        fieldType: goog.proto2.Message.FieldType.INT64,
3703
        defaultValue: 1000000000000000001,
3704
        type: Number
3705
      },
3706
      51: {
3707
        name: 'optional_int64_string',
3708
        fieldType: goog.proto2.Message.FieldType.INT64,
3709
        defaultValue: '1000000000000000001',
3710
        type: String
3711
      },
3712
      31: {
3713
        name: 'repeated_int32',
3714
        repeated: true,
3715
        fieldType: goog.proto2.Message.FieldType.INT32,
3716
        type: Number
3717
      },
3718
      32: {
3719
        name: 'repeated_int64',
3720
        repeated: true,
3721
        fieldType: goog.proto2.Message.FieldType.INT64,
3722
        type: String
3723
      },
3724
      33: {
3725
        name: 'repeated_uint32',
3726
        repeated: true,
3727
        fieldType: goog.proto2.Message.FieldType.UINT32,
3728
        type: Number
3729
      },
3730
      34: {
3731
        name: 'repeated_uint64',
3732
        repeated: true,
3733
        fieldType: goog.proto2.Message.FieldType.UINT64,
3734
        type: String
3735
      },
3736
      35: {
3737
        name: 'repeated_sint32',
3738
        repeated: true,
3739
        fieldType: goog.proto2.Message.FieldType.SINT32,
3740
        type: Number
3741
      },
3742
      36: {
3743
        name: 'repeated_sint64',
3744
        repeated: true,
3745
        fieldType: goog.proto2.Message.FieldType.SINT64,
3746
        type: String
3747
      },
3748
      37: {
3749
        name: 'repeated_fixed32',
3750
        repeated: true,
3751
        fieldType: goog.proto2.Message.FieldType.FIXED32,
3752
        type: Number
3753
      },
3754
      38: {
3755
        name: 'repeated_fixed64',
3756
        repeated: true,
3757
        fieldType: goog.proto2.Message.FieldType.FIXED64,
3758
        type: String
3759
      },
3760
      39: {
3761
        name: 'repeated_sfixed32',
3762
        repeated: true,
3763
        fieldType: goog.proto2.Message.FieldType.SFIXED32,
3764
        type: Number
3765
      },
3766
      40: {
3767
        name: 'repeated_sfixed64',
3768
        repeated: true,
3769
        fieldType: goog.proto2.Message.FieldType.SFIXED64,
3770
        type: String
3771
      },
3772
      41: {
3773
        name: 'repeated_float',
3774
        repeated: true,
3775
        fieldType: goog.proto2.Message.FieldType.FLOAT,
3776
        type: Number
3777
      },
3778
      42: {
3779
        name: 'repeated_double',
3780
        repeated: true,
3781
        fieldType: goog.proto2.Message.FieldType.DOUBLE,
3782
        type: Number
3783
      },
3784
      43: {
3785
        name: 'repeated_bool',
3786
        repeated: true,
3787
        fieldType: goog.proto2.Message.FieldType.BOOL,
3788
        type: Boolean
3789
      },
3790
      44: {
3791
        name: 'repeated_string',
3792
        repeated: true,
3793
        fieldType: goog.proto2.Message.FieldType.STRING,
3794
        type: String
3795
      },
3796
      45: {
3797
        name: 'repeated_bytes',
3798
        repeated: true,
3799
        fieldType: goog.proto2.Message.FieldType.BYTES,
3800
        type: String
3801
      },
3802
      46: {
3803
        name: 'repeatedgroup',
3804
        repeated: true,
3805
        fieldType: goog.proto2.Message.FieldType.GROUP,
3806
        type: proto2.TestAllTypes.RepeatedGroup
3807
      },
3808
      48: {
3809
        name: 'repeated_nested_message',
3810
        repeated: true,
3811
        fieldType: goog.proto2.Message.FieldType.MESSAGE,
3812
        type: proto2.TestAllTypes.NestedMessage
3813
      },
3814
      49: {
3815
        name: 'repeated_nested_enum',
3816
        repeated: true,
3817
        fieldType: goog.proto2.Message.FieldType.ENUM,
3818
        defaultValue: proto2.TestAllTypes.NestedEnum.FOO,
3819
        type: proto2.TestAllTypes.NestedEnum
3820
      },
3821
      52: {
3822
        name: 'repeated_int64_number',
3823
        repeated: true,
3824
        fieldType: goog.proto2.Message.FieldType.INT64,
3825
        type: Number
3826
      },
3827
      53: {
3828
        name: 'repeated_int64_string',
3829
        repeated: true,
3830
        fieldType: goog.proto2.Message.FieldType.INT64,
3831
        type: String
3832
      },
3833
      54: {
3834
        name: 'packed_int32',
3835
        repeated: true,
3836
        packed: true,
3837
        fieldType: goog.proto2.Message.FieldType.INT32,
3838
        type: Number
3839
      },
3840
      55: {
3841
        name: 'packed_int64',
3842
        repeated: true,
3843
        packed: true,
3844
        fieldType: goog.proto2.Message.FieldType.INT64,
3845
        type: Number
3846
      },
3847
      56: {
3848
        name: 'packed_uint32',
3849
        repeated: true,
3850
        packed: true,
3851
        fieldType: goog.proto2.Message.FieldType.UINT32,
3852
        type: Number
3853
      },
3854
      57: {
3855
        name: 'packed_uint64',
3856
        repeated: true,
3857
        packed: true,
3858
        fieldType: goog.proto2.Message.FieldType.UINT64,
3859
        type: Number
3860
      },
3861
      58: {
3862
        name: 'packed_sint32',
3863
        repeated: true,
3864
        packed: true,
3865
        fieldType: goog.proto2.Message.FieldType.SINT32,
3866
        type: Number
3867
      },
3868
      59: {
3869
        name: 'packed_sint64',
3870
        repeated: true,
3871
        packed: true,
3872
        fieldType: goog.proto2.Message.FieldType.SINT64,
3873
        type: Number
3874
      },
3875
      60: {
3876
        name: 'packed_fixed32',
3877
        repeated: true,
3878
        packed: true,
3879
        fieldType: goog.proto2.Message.FieldType.FIXED32,
3880
        type: Number
3881
      },
3882
      61: {
3883
        name: 'packed_fixed64',
3884
        repeated: true,
3885
        packed: true,
3886
        fieldType: goog.proto2.Message.FieldType.FIXED64,
3887
        type: Number
3888
      },
3889
      62: {
3890
        name: 'packed_sfixed32',
3891
        repeated: true,
3892
        packed: true,
3893
        fieldType: goog.proto2.Message.FieldType.SFIXED32,
3894
        type: Number
3895
      },
3896
      63: {
3897
        name: 'packed_sfixed64',
3898
        repeated: true,
3899
        packed: true,
3900
        fieldType: goog.proto2.Message.FieldType.SFIXED64,
3901
        type: Number
3902
      },
3903
      64: {
3904
        name: 'packed_float',
3905
        repeated: true,
3906
        packed: true,
3907
        fieldType: goog.proto2.Message.FieldType.FLOAT,
3908
        type: Number
3909
      },
3910
      65: {
3911
        name: 'packed_double',
3912
        repeated: true,
3913
        packed: true,
3914
        fieldType: goog.proto2.Message.FieldType.DOUBLE,
3915
        type: Number
3916
      },
3917
      66: {
3918
        name: 'packed_bool',
3919
        repeated: true,
3920
        packed: true,
3921
        fieldType: goog.proto2.Message.FieldType.BOOL,
3922
        type: Boolean
3923
      }
3924
    };
3925
    proto2.TestAllTypes.descriptor_ = descriptor =
3926
        goog.proto2.Message.createDescriptor(
3927
             proto2.TestAllTypes, descriptorObj);
3928
  }
3929
  return descriptor;
3930
};
3931

3932

3933
/** @nocollapse */
3934
proto2.TestAllTypes.getDescriptor =
3935
    proto2.TestAllTypes.prototype.getDescriptor;
3936

3937

3938
/** @override */
3939
proto2.TestAllTypes.NestedMessage.prototype.getDescriptor = function() {
3940
  var descriptor = proto2.TestAllTypes.NestedMessage.descriptor_;
3941
  if (!descriptor) {
3942
    // The descriptor is created lazily when we instantiate a new instance.
3943
    var descriptorObj = {
3944
      0: {
3945
        name: 'NestedMessage',
3946
        containingType: proto2.TestAllTypes,
3947
        fullName: 'TestAllTypes.NestedMessage'
3948
      },
3949
      1: {
3950
        name: 'b',
3951
        fieldType: goog.proto2.Message.FieldType.INT32,
3952
        type: Number
3953
      },
3954
      2: {
3955
        name: 'c',
3956
        fieldType: goog.proto2.Message.FieldType.INT32,
3957
        type: Number
3958
      }
3959
    };
3960
    proto2.TestAllTypes.NestedMessage.descriptor_ = descriptor =
3961
        goog.proto2.Message.createDescriptor(
3962
             proto2.TestAllTypes.NestedMessage, descriptorObj);
3963
  }
3964
  return descriptor;
3965
};
3966

3967

3968
/** @nocollapse */
3969
proto2.TestAllTypes.NestedMessage.getDescriptor =
3970
    proto2.TestAllTypes.NestedMessage.prototype.getDescriptor;
3971

3972

3973
/** @override */
3974
proto2.TestAllTypes.OptionalGroup.prototype.getDescriptor = function() {
3975
  var descriptor = proto2.TestAllTypes.OptionalGroup.descriptor_;
3976
  if (!descriptor) {
3977
    // The descriptor is created lazily when we instantiate a new instance.
3978
    var descriptorObj = {
3979
      0: {
3980
        name: 'OptionalGroup',
3981
        containingType: proto2.TestAllTypes,
3982
        fullName: 'TestAllTypes.OptionalGroup'
3983
      },
3984
      17: {
3985
        name: 'a',
3986
        fieldType: goog.proto2.Message.FieldType.INT32,
3987
        type: Number
3988
      }
3989
    };
3990
    proto2.TestAllTypes.OptionalGroup.descriptor_ = descriptor =
3991
        goog.proto2.Message.createDescriptor(
3992
             proto2.TestAllTypes.OptionalGroup, descriptorObj);
3993
  }
3994
  return descriptor;
3995
};
3996

3997

3998
/** @nocollapse */
3999
proto2.TestAllTypes.OptionalGroup.getDescriptor =
4000
    proto2.TestAllTypes.OptionalGroup.prototype.getDescriptor;
4001

4002

4003
/** @override */
4004
proto2.TestAllTypes.RepeatedGroup.prototype.getDescriptor = function() {
4005
  var descriptor = proto2.TestAllTypes.RepeatedGroup.descriptor_;
4006
  if (!descriptor) {
4007
    // The descriptor is created lazily when we instantiate a new instance.
4008
    var descriptorObj = {
4009
      0: {
4010
        name: 'RepeatedGroup',
4011
        containingType: proto2.TestAllTypes,
4012
        fullName: 'TestAllTypes.RepeatedGroup'
4013
      },
4014
      47: {
4015
        name: 'a',
4016
        repeated: true,
4017
        fieldType: goog.proto2.Message.FieldType.INT32,
4018
        type: Number
4019
      }
4020
    };
4021
    proto2.TestAllTypes.RepeatedGroup.descriptor_ = descriptor =
4022
        goog.proto2.Message.createDescriptor(
4023
             proto2.TestAllTypes.RepeatedGroup, descriptorObj);
4024
  }
4025
  return descriptor;
4026
};
4027

4028

4029
/** @nocollapse */
4030
proto2.TestAllTypes.RepeatedGroup.getDescriptor =
4031
    proto2.TestAllTypes.RepeatedGroup.prototype.getDescriptor;
4032

4033

4034
/** @override */
4035
proto2.TestDefaultParent.prototype.getDescriptor = function() {
4036
  var descriptor = proto2.TestDefaultParent.descriptor_;
4037
  if (!descriptor) {
4038
    // The descriptor is created lazily when we instantiate a new instance.
4039
    var descriptorObj = {
4040
      0: {
4041
        name: 'TestDefaultParent',
4042
        fullName: 'TestDefaultParent'
4043
      },
4044
      1: {
4045
        name: 'child',
4046
        fieldType: goog.proto2.Message.FieldType.MESSAGE,
4047
        type: proto2.TestDefaultChild
4048
      }
4049
    };
4050
    proto2.TestDefaultParent.descriptor_ = descriptor =
4051
        goog.proto2.Message.createDescriptor(
4052
             proto2.TestDefaultParent, descriptorObj);
4053
  }
4054
  return descriptor;
4055
};
4056

4057

4058
/** @nocollapse */
4059
proto2.TestDefaultParent.getDescriptor =
4060
    proto2.TestDefaultParent.prototype.getDescriptor;
4061

4062

4063
/** @override */
4064
proto2.TestDefaultChild.prototype.getDescriptor = function() {
4065
  var descriptor = proto2.TestDefaultChild.descriptor_;
4066
  if (!descriptor) {
4067
    // The descriptor is created lazily when we instantiate a new instance.
4068
    var descriptorObj = {
4069
      0: {
4070
        name: 'TestDefaultChild',
4071
        fullName: 'TestDefaultChild'
4072
      },
4073
      1: {
4074
        name: 'foo',
4075
        fieldType: goog.proto2.Message.FieldType.BOOL,
4076
        defaultValue: true,
4077
        type: Boolean
4078
      }
4079
    };
4080
    proto2.TestDefaultChild.descriptor_ = descriptor =
4081
        goog.proto2.Message.createDescriptor(
4082
             proto2.TestDefaultChild, descriptorObj);
4083
  }
4084
  return descriptor;
4085
};
4086

4087

4088
/** @nocollapse */
4089
proto2.TestDefaultChild.getDescriptor =
4090
    proto2.TestDefaultChild.prototype.getDescriptor;
4091

4092