1 /*
2 * This class is an auto-generated source file for a HAPI
3 * HL7 v2.x standard structure class.
4 *
5 * For more information, visit: http://hl7api.sourceforge.net/
6 *
7 * The contents of this file are subject to the Mozilla Public License Version 1.1
8 * (the "License"); you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/
10 * Software distributed under the License is distributed on an "AS IS" basis,
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
12 * specific language governing rights and limitations under the License.
13 *
14 * The Original Code is "[file_name]". Description:
15 * "[one_line_description]"
16 *
17 * The Initial Developer of the Original Code is University Health Network. Copyright (C)
18 * 2012. All Rights Reserved.
19 *
20 * Contributor(s): ______________________________________.
21 *
22 * Alternatively, the contents of this file may be used under the terms of the
23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are
24 * applicable instead of those above. If you wish to allow use of your version of this
25 * file only under the terms of the GPL and not to allow others to use your version
26 * of this file under the MPL, indicate your decision by deleting the provisions above
27 * and replace them with the notice and other provisions required by the GPL License.
28 * If you do not delete the provisions above, a recipient may use your version of
29 * this file under either the MPL or the GPL.
30 *
31 */
32
33
34 package ca.uhn.hl7v2.model.v22.message;
35
36 import ca.uhn.hl7v2.model.v22.group.*;
37 import ca.uhn.hl7v2.model.v22.segment.*;
38
39 import ca.uhn.hl7v2.HL7Exception;
40 import ca.uhn.hl7v2.parser.ModelClassFactory;
41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
42 import ca.uhn.hl7v2.model.*;
43
44
45 /**
46 * <p>Represents a ADT_A07 message structure (see chapter ?). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (MESSAGE HEADER) <b> </b> </li>
50 * <li>2: EVN (EVENT TYPE) <b> </b> </li>
51 * <li>3: PID (PATIENT IDENTIFICATION) <b> </b> </li>
52 * <li>4: MRG (MERGE PATIENT INFORMATION) <b>optional </b> </li>
53 * <li>5: NK1 (NEXT OF KIN) <b>optional repeating</b> </li>
54 * <li>6: PV1 (PATIENT VISIT) <b> </b> </li>
55 * <li>7: PV2 (PATIENT VISIT - additional information) <b>optional </b> </li>
56 * <li>8: OBX (OBSERVATION RESULT) <b>optional repeating</b> </li>
57 * <li>9: AL1 (PATIENT ALLERGY INFORMATION) <b>optional repeating</b> </li>
58 * <li>10: DG1 (DIAGNOSIS) <b>optional repeating</b> </li>
59 * <li>11: PR1 (PROCEDURES) <b>optional repeating</b> </li>
60 * <li>12: GT1 (GUARANTOR) <b>optional repeating</b> </li>
61 * <li>13: ADT_A07_INSURANCE (a Group object) <b>optional repeating</b> </li>
62 * <li>14: ACC (ACCIDENT) <b>optional </b> </li>
63 * <li>15: UB1 (UB82 DATA) <b>optional </b> </li>
64 * <li>16: UB2 (UB92 DATA) <b>optional </b> </li>
65 * </ul>
66 */
67 //@SuppressWarnings("unused")
68 public class ADT_A07 extends AbstractMessage {
69
70 /**
71 * Creates a new ADT_A07 message with DefaultModelClassFactory.
72 */
73 public ADT_A07() {
74 this(new DefaultModelClassFactory());
75 }
76
77 /**
78 * Creates a new ADT_A07 message with custom ModelClassFactory.
79 */
80 public ADT_A07(ModelClassFactory factory) {
81 super(factory);
82 init(factory);
83 }
84
85 private void init(ModelClassFactory factory) {
86 try {
87 this.add(MSH.class, true, false);
88 this.add(EVN.class, true, false);
89 this.add(PID.class, true, false);
90 this.add(MRG.class, false, false);
91 this.add(NK1.class, false, true);
92 this.add(PV1.class, true, false);
93 this.add(PV2.class, false, false);
94 this.add(OBX.class, false, true);
95 this.add(AL1.class, false, true);
96 this.add(DG1.class, false, true);
97 this.add(PR1.class, false, true);
98 this.add(GT1.class, false, true);
99 this.add(ADT_A07_INSURANCE.class, false, true);
100 this.add(ACC.class, false, false);
101 this.add(UB1.class, false, false);
102 this.add(UB2.class, false, false);
103 } catch(HL7Exception e) {
104 log.error("Unexpected error creating ADT_A07 - this is probably a bug in the source code generator.", e);
105 }
106 }
107
108
109 /**
110 * Returns "2.2"
111 */
112 public String getVersion() {
113 return "2.2";
114 }
115
116
117
118
119 /**
120 * <p>
121 * Returns
122 * MSH (MESSAGE HEADER) - creates it if necessary
123 * </p>
124 *
125 *
126 */
127 public MSH getMSH() {
128 return getTyped("MSH", MSH.class);
129 }
130
131
132
133
134
135 /**
136 * <p>
137 * Returns
138 * EVN (EVENT TYPE) - creates it if necessary
139 * </p>
140 *
141 *
142 */
143 public EVN getEVN() {
144 return getTyped("EVN", EVN.class);
145 }
146
147
148
149
150
151 /**
152 * <p>
153 * Returns
154 * PID (PATIENT IDENTIFICATION) - creates it if necessary
155 * </p>
156 *
157 *
158 */
159 public PID getPID() {
160 return getTyped("PID", PID.class);
161 }
162
163
164
165
166
167 /**
168 * <p>
169 * Returns
170 * MRG (MERGE PATIENT INFORMATION) - creates it if necessary
171 * </p>
172 *
173 *
174 */
175 public MRG getMRG() {
176 return getTyped("MRG", MRG.class);
177 }
178
179
180
181
182
183 /**
184 * <p>
185 * Returns
186 * the first repetition of
187 * NK1 (NEXT OF KIN) - creates it if necessary
188 * </p>
189 *
190 *
191 */
192 public NK1 getNK1() {
193 return getTyped("NK1", NK1.class);
194 }
195
196
197 /**
198 * <p>
199 * Returns a specific repetition of
200 * NK1 (NEXT OF KIN) - creates it if necessary
201 * </p>
202 *
203 *
204 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
205 * @throws HL7Exception if the repetition requested is more than one
206 * greater than the number of existing repetitions.
207 */
208 public NK1 getNK1(int rep) {
209 return getTyped("NK1", rep, NK1.class);
210 }
211
212 /**
213 * <p>
214 * Returns the number of existing repetitions of NK1
215 * </p>
216 *
217 */
218 public int getNK1Reps() {
219 return getReps("NK1");
220 }
221
222 /**
223 * <p>
224 * Returns a non-modifiable List containing all current existing repetitions of NK1.
225 * <p>
226 * <p>
227 * Note that unlike {@link #getNK1()}, this method will not create any reps
228 * if none are already present, so an empty list may be returned.
229 * </p>
230 *
231 */
232 public java.util.List<NK1> getNK1All() throws HL7Exception {
233 return getAllAsList("NK1", NK1.class);
234 }
235
236 /**
237 * <p>
238 * Inserts a specific repetition of NK1 (NEXT OF KIN)
239 * </p>
240 *
241 *
242 * @see AbstractGroup#insertRepetition(Structure, int)
243 */
244 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
245 super.insertRepetition( "NK1", structure, rep);
246 }
247
248
249 /**
250 * <p>
251 * Inserts a specific repetition of NK1 (NEXT OF KIN)
252 * </p>
253 *
254 *
255 * @see AbstractGroup#insertRepetition(Structure, int)
256 */
257 public NK1 insertNK1(int rep) throws HL7Exception {
258 return (NK1)super.insertRepetition("NK1", rep);
259 }
260
261
262 /**
263 * <p>
264 * Removes a specific repetition of NK1 (NEXT OF KIN)
265 * </p>
266 *
267 *
268 * @see AbstractGroup#removeRepetition(String, int)
269 */
270 public NK1 removeNK1(int rep) throws HL7Exception {
271 return (NK1)super.removeRepetition("NK1", rep);
272 }
273
274
275
276
277 /**
278 * <p>
279 * Returns
280 * PV1 (PATIENT VISIT) - creates it if necessary
281 * </p>
282 *
283 *
284 */
285 public PV1 getPV1() {
286 return getTyped("PV1", PV1.class);
287 }
288
289
290
291
292
293 /**
294 * <p>
295 * Returns
296 * PV2 (PATIENT VISIT - additional information) - creates it if necessary
297 * </p>
298 *
299 *
300 */
301 public PV2 getPV2() {
302 return getTyped("PV2", PV2.class);
303 }
304
305
306
307
308
309 /**
310 * <p>
311 * Returns
312 * the first repetition of
313 * OBX (OBSERVATION RESULT) - creates it if necessary
314 * </p>
315 *
316 *
317 */
318 public OBX getOBX() {
319 return getTyped("OBX", OBX.class);
320 }
321
322
323 /**
324 * <p>
325 * Returns a specific repetition of
326 * OBX (OBSERVATION RESULT) - creates it if necessary
327 * </p>
328 *
329 *
330 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
331 * @throws HL7Exception if the repetition requested is more than one
332 * greater than the number of existing repetitions.
333 */
334 public OBX getOBX(int rep) {
335 return getTyped("OBX", rep, OBX.class);
336 }
337
338 /**
339 * <p>
340 * Returns the number of existing repetitions of OBX
341 * </p>
342 *
343 */
344 public int getOBXReps() {
345 return getReps("OBX");
346 }
347
348 /**
349 * <p>
350 * Returns a non-modifiable List containing all current existing repetitions of OBX.
351 * <p>
352 * <p>
353 * Note that unlike {@link #getOBX()}, this method will not create any reps
354 * if none are already present, so an empty list may be returned.
355 * </p>
356 *
357 */
358 public java.util.List<OBX> getOBXAll() throws HL7Exception {
359 return getAllAsList("OBX", OBX.class);
360 }
361
362 /**
363 * <p>
364 * Inserts a specific repetition of OBX (OBSERVATION RESULT)
365 * </p>
366 *
367 *
368 * @see AbstractGroup#insertRepetition(Structure, int)
369 */
370 public void insertOBX(OBX structure, int rep) throws HL7Exception {
371 super.insertRepetition( "OBX", structure, rep);
372 }
373
374
375 /**
376 * <p>
377 * Inserts a specific repetition of OBX (OBSERVATION RESULT)
378 * </p>
379 *
380 *
381 * @see AbstractGroup#insertRepetition(Structure, int)
382 */
383 public OBX insertOBX(int rep) throws HL7Exception {
384 return (OBX)super.insertRepetition("OBX", rep);
385 }
386
387
388 /**
389 * <p>
390 * Removes a specific repetition of OBX (OBSERVATION RESULT)
391 * </p>
392 *
393 *
394 * @see AbstractGroup#removeRepetition(String, int)
395 */
396 public OBX removeOBX(int rep) throws HL7Exception {
397 return (OBX)super.removeRepetition("OBX", rep);
398 }
399
400
401
402
403 /**
404 * <p>
405 * Returns
406 * the first repetition of
407 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary
408 * </p>
409 *
410 *
411 */
412 public AL1 getAL1() {
413 return getTyped("AL1", AL1.class);
414 }
415
416
417 /**
418 * <p>
419 * Returns a specific repetition of
420 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary
421 * </p>
422 *
423 *
424 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
425 * @throws HL7Exception if the repetition requested is more than one
426 * greater than the number of existing repetitions.
427 */
428 public AL1 getAL1(int rep) {
429 return getTyped("AL1", rep, AL1.class);
430 }
431
432 /**
433 * <p>
434 * Returns the number of existing repetitions of AL1
435 * </p>
436 *
437 */
438 public int getAL1Reps() {
439 return getReps("AL1");
440 }
441
442 /**
443 * <p>
444 * Returns a non-modifiable List containing all current existing repetitions of AL1.
445 * <p>
446 * <p>
447 * Note that unlike {@link #getAL1()}, this method will not create any reps
448 * if none are already present, so an empty list may be returned.
449 * </p>
450 *
451 */
452 public java.util.List<AL1> getAL1All() throws HL7Exception {
453 return getAllAsList("AL1", AL1.class);
454 }
455
456 /**
457 * <p>
458 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
459 * </p>
460 *
461 *
462 * @see AbstractGroup#insertRepetition(Structure, int)
463 */
464 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
465 super.insertRepetition( "AL1", structure, rep);
466 }
467
468
469 /**
470 * <p>
471 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
472 * </p>
473 *
474 *
475 * @see AbstractGroup#insertRepetition(Structure, int)
476 */
477 public AL1 insertAL1(int rep) throws HL7Exception {
478 return (AL1)super.insertRepetition("AL1", rep);
479 }
480
481
482 /**
483 * <p>
484 * Removes a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
485 * </p>
486 *
487 *
488 * @see AbstractGroup#removeRepetition(String, int)
489 */
490 public AL1 removeAL1(int rep) throws HL7Exception {
491 return (AL1)super.removeRepetition("AL1", rep);
492 }
493
494
495
496
497 /**
498 * <p>
499 * Returns
500 * the first repetition of
501 * DG1 (DIAGNOSIS) - creates it if necessary
502 * </p>
503 *
504 *
505 */
506 public DG1 getDG1() {
507 return getTyped("DG1", DG1.class);
508 }
509
510
511 /**
512 * <p>
513 * Returns a specific repetition of
514 * DG1 (DIAGNOSIS) - creates it if necessary
515 * </p>
516 *
517 *
518 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
519 * @throws HL7Exception if the repetition requested is more than one
520 * greater than the number of existing repetitions.
521 */
522 public DG1 getDG1(int rep) {
523 return getTyped("DG1", rep, DG1.class);
524 }
525
526 /**
527 * <p>
528 * Returns the number of existing repetitions of DG1
529 * </p>
530 *
531 */
532 public int getDG1Reps() {
533 return getReps("DG1");
534 }
535
536 /**
537 * <p>
538 * Returns a non-modifiable List containing all current existing repetitions of DG1.
539 * <p>
540 * <p>
541 * Note that unlike {@link #getDG1()}, this method will not create any reps
542 * if none are already present, so an empty list may be returned.
543 * </p>
544 *
545 */
546 public java.util.List<DG1> getDG1All() throws HL7Exception {
547 return getAllAsList("DG1", DG1.class);
548 }
549
550 /**
551 * <p>
552 * Inserts a specific repetition of DG1 (DIAGNOSIS)
553 * </p>
554 *
555 *
556 * @see AbstractGroup#insertRepetition(Structure, int)
557 */
558 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
559 super.insertRepetition( "DG1", structure, rep);
560 }
561
562
563 /**
564 * <p>
565 * Inserts a specific repetition of DG1 (DIAGNOSIS)
566 * </p>
567 *
568 *
569 * @see AbstractGroup#insertRepetition(Structure, int)
570 */
571 public DG1 insertDG1(int rep) throws HL7Exception {
572 return (DG1)super.insertRepetition("DG1", rep);
573 }
574
575
576 /**
577 * <p>
578 * Removes a specific repetition of DG1 (DIAGNOSIS)
579 * </p>
580 *
581 *
582 * @see AbstractGroup#removeRepetition(String, int)
583 */
584 public DG1 removeDG1(int rep) throws HL7Exception {
585 return (DG1)super.removeRepetition("DG1", rep);
586 }
587
588
589
590
591 /**
592 * <p>
593 * Returns
594 * the first repetition of
595 * PR1 (PROCEDURES) - creates it if necessary
596 * </p>
597 *
598 *
599 */
600 public PR1 getPR1() {
601 return getTyped("PR1", PR1.class);
602 }
603
604
605 /**
606 * <p>
607 * Returns a specific repetition of
608 * PR1 (PROCEDURES) - creates it if necessary
609 * </p>
610 *
611 *
612 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
613 * @throws HL7Exception if the repetition requested is more than one
614 * greater than the number of existing repetitions.
615 */
616 public PR1 getPR1(int rep) {
617 return getTyped("PR1", rep, PR1.class);
618 }
619
620 /**
621 * <p>
622 * Returns the number of existing repetitions of PR1
623 * </p>
624 *
625 */
626 public int getPR1Reps() {
627 return getReps("PR1");
628 }
629
630 /**
631 * <p>
632 * Returns a non-modifiable List containing all current existing repetitions of PR1.
633 * <p>
634 * <p>
635 * Note that unlike {@link #getPR1()}, this method will not create any reps
636 * if none are already present, so an empty list may be returned.
637 * </p>
638 *
639 */
640 public java.util.List<PR1> getPR1All() throws HL7Exception {
641 return getAllAsList("PR1", PR1.class);
642 }
643
644 /**
645 * <p>
646 * Inserts a specific repetition of PR1 (PROCEDURES)
647 * </p>
648 *
649 *
650 * @see AbstractGroup#insertRepetition(Structure, int)
651 */
652 public void insertPR1(PR1 structure, int rep) throws HL7Exception {
653 super.insertRepetition( "PR1", structure, rep);
654 }
655
656
657 /**
658 * <p>
659 * Inserts a specific repetition of PR1 (PROCEDURES)
660 * </p>
661 *
662 *
663 * @see AbstractGroup#insertRepetition(Structure, int)
664 */
665 public PR1 insertPR1(int rep) throws HL7Exception {
666 return (PR1)super.insertRepetition("PR1", rep);
667 }
668
669
670 /**
671 * <p>
672 * Removes a specific repetition of PR1 (PROCEDURES)
673 * </p>
674 *
675 *
676 * @see AbstractGroup#removeRepetition(String, int)
677 */
678 public PR1 removePR1(int rep) throws HL7Exception {
679 return (PR1)super.removeRepetition("PR1", rep);
680 }
681
682
683
684
685 /**
686 * <p>
687 * Returns
688 * the first repetition of
689 * GT1 (GUARANTOR) - creates it if necessary
690 * </p>
691 *
692 *
693 */
694 public GT1 getGT1() {
695 return getTyped("GT1", GT1.class);
696 }
697
698
699 /**
700 * <p>
701 * Returns a specific repetition of
702 * GT1 (GUARANTOR) - creates it if necessary
703 * </p>
704 *
705 *
706 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
707 * @throws HL7Exception if the repetition requested is more than one
708 * greater than the number of existing repetitions.
709 */
710 public GT1 getGT1(int rep) {
711 return getTyped("GT1", rep, GT1.class);
712 }
713
714 /**
715 * <p>
716 * Returns the number of existing repetitions of GT1
717 * </p>
718 *
719 */
720 public int getGT1Reps() {
721 return getReps("GT1");
722 }
723
724 /**
725 * <p>
726 * Returns a non-modifiable List containing all current existing repetitions of GT1.
727 * <p>
728 * <p>
729 * Note that unlike {@link #getGT1()}, this method will not create any reps
730 * if none are already present, so an empty list may be returned.
731 * </p>
732 *
733 */
734 public java.util.List<GT1> getGT1All() throws HL7Exception {
735 return getAllAsList("GT1", GT1.class);
736 }
737
738 /**
739 * <p>
740 * Inserts a specific repetition of GT1 (GUARANTOR)
741 * </p>
742 *
743 *
744 * @see AbstractGroup#insertRepetition(Structure, int)
745 */
746 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
747 super.insertRepetition( "GT1", structure, rep);
748 }
749
750
751 /**
752 * <p>
753 * Inserts a specific repetition of GT1 (GUARANTOR)
754 * </p>
755 *
756 *
757 * @see AbstractGroup#insertRepetition(Structure, int)
758 */
759 public GT1 insertGT1(int rep) throws HL7Exception {
760 return (GT1)super.insertRepetition("GT1", rep);
761 }
762
763
764 /**
765 * <p>
766 * Removes a specific repetition of GT1 (GUARANTOR)
767 * </p>
768 *
769 *
770 * @see AbstractGroup#removeRepetition(String, int)
771 */
772 public GT1 removeGT1(int rep) throws HL7Exception {
773 return (GT1)super.removeRepetition("GT1", rep);
774 }
775
776
777
778
779 /**
780 * <p>
781 * Returns
782 * the first repetition of
783 * INSURANCE (a Group object) - creates it if necessary
784 * </p>
785 *
786 *
787 */
788 public ADT_A07_INSURANCE getINSURANCE() {
789 return getTyped("INSURANCE", ADT_A07_INSURANCE.class);
790 }
791
792
793 /**
794 * <p>
795 * Returns a specific repetition of
796 * INSURANCE (a Group object) - creates it if necessary
797 * </p>
798 *
799 *
800 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
801 * @throws HL7Exception if the repetition requested is more than one
802 * greater than the number of existing repetitions.
803 */
804 public ADT_A07_INSURANCE getINSURANCE(int rep) {
805 return getTyped("INSURANCE", rep, ADT_A07_INSURANCE.class);
806 }
807
808 /**
809 * <p>
810 * Returns the number of existing repetitions of INSURANCE
811 * </p>
812 *
813 */
814 public int getINSURANCEReps() {
815 return getReps("INSURANCE");
816 }
817
818 /**
819 * <p>
820 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
821 * <p>
822 * <p>
823 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
824 * if none are already present, so an empty list may be returned.
825 * </p>
826 *
827 */
828 public java.util.List<ADT_A07_INSURANCE> getINSURANCEAll() throws HL7Exception {
829 return getAllAsList("INSURANCE", ADT_A07_INSURANCE.class);
830 }
831
832 /**
833 * <p>
834 * Inserts a specific repetition of INSURANCE (a Group object)
835 * </p>
836 *
837 *
838 * @see AbstractGroup#insertRepetition(Structure, int)
839 */
840 public void insertINSURANCE(ADT_A07_INSURANCE structure, int rep) throws HL7Exception {
841 super.insertRepetition( "INSURANCE", structure, rep);
842 }
843
844
845 /**
846 * <p>
847 * Inserts a specific repetition of INSURANCE (a Group object)
848 * </p>
849 *
850 *
851 * @see AbstractGroup#insertRepetition(Structure, int)
852 */
853 public ADT_A07_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
854 return (ADT_A07_INSURANCE)super.insertRepetition("INSURANCE", rep);
855 }
856
857
858 /**
859 * <p>
860 * Removes a specific repetition of INSURANCE (a Group object)
861 * </p>
862 *
863 *
864 * @see AbstractGroup#removeRepetition(String, int)
865 */
866 public ADT_A07_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
867 return (ADT_A07_INSURANCE)super.removeRepetition("INSURANCE", rep);
868 }
869
870
871
872
873 /**
874 * <p>
875 * Returns
876 * ACC (ACCIDENT) - creates it if necessary
877 * </p>
878 *
879 *
880 */
881 public ACC getACC() {
882 return getTyped("ACC", ACC.class);
883 }
884
885
886
887
888
889 /**
890 * <p>
891 * Returns
892 * UB1 (UB82 DATA) - creates it if necessary
893 * </p>
894 *
895 *
896 */
897 public UB1 getUB1() {
898 return getTyped("UB1", UB1.class);
899 }
900
901
902
903
904
905 /**
906 * <p>
907 * Returns
908 * UB2 (UB92 DATA) - creates it if necessary
909 * </p>
910 *
911 *
912 */
913 public UB2 getUB2() {
914 return getTyped("UB2", UB2.class);
915 }
916
917
918
919
920 }
921