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.v281.message;
35
36 import ca.uhn.hl7v2.model.v281.group.*;
37 import ca.uhn.hl7v2.model.v281.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_A06 message structure (see chapter 3.3.6). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message Header) <b> </b> </li>
50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li>
51 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li>
52 * <li>4: EVN (Event Type) <b> </b> </li>
53 * <li>5: PID (Patient Identification) <b> </b> </li>
54 * <li>6: PD1 (Patient Additional Demographic) <b>optional </b> </li>
55 * <li>7: ARV (Access Restriction) <b>optional repeating</b> </li>
56 * <li>8: ROL (Role) <b>optional repeating</b> </li>
57 * <li>9: MRG (Merge Patient Information) <b>optional </b> </li>
58 * <li>10: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li>
59 * <li>11: PV1 (Patient Visit) <b> </b> </li>
60 * <li>12: PV2 (Patient Visit - Additional Information) <b>optional </b> </li>
61 * <li>13: ARV (Access Restriction) <b>optional repeating</b> </li>
62 * <li>14: ROL (Role) <b>optional repeating</b> </li>
63 * <li>15: DB1 (Disability) <b>optional repeating</b> </li>
64 * <li>16: OBX (Observation/Result) <b>optional repeating</b> </li>
65 * <li>17: AL1 (Patient Allergy Information) <b>optional repeating</b> </li>
66 * <li>18: DG1 (Diagnosis) <b>optional repeating</b> </li>
67 * <li>19: DRG (Diagnosis Related Group) <b>optional </b> </li>
68 * <li>20: ADT_A06_PROCEDURE (a Group object) <b>optional repeating</b> </li>
69 * <li>21: GT1 (Guarantor) <b>optional repeating</b> </li>
70 * <li>22: ADT_A06_INSURANCE (a Group object) <b>optional repeating</b> </li>
71 * <li>23: ACC (Accident) <b>optional </b> </li>
72 * <li>24: UB1 () <b>optional </b> </li>
73 * <li>25: UB2 (Uniform Billing Data) <b>optional </b> </li>
74 * </ul>
75 */
76 //@SuppressWarnings("unused")
77 public class ADT_A06 extends AbstractMessage {
78
79 /**
80 * Creates a new ADT_A06 message with DefaultModelClassFactory.
81 */
82 public ADT_A06() {
83 this(new DefaultModelClassFactory());
84 }
85
86 /**
87 * Creates a new ADT_A06 message with custom ModelClassFactory.
88 */
89 public ADT_A06(ModelClassFactory factory) {
90 super(factory);
91 init(factory);
92 }
93
94 private void init(ModelClassFactory factory) {
95 try {
96 this.add(MSH.class, true, false);
97 this.add(SFT.class, false, true);
98 this.add(UAC.class, false, false);
99 this.add(EVN.class, true, false);
100 this.add(PID.class, true, false);
101 this.add(PD1.class, false, false);
102 this.add(ARV.class, false, true);
103 this.add(ROL.class, false, true);
104 this.add(MRG.class, false, false);
105 this.add(NK1.class, false, true);
106 this.add(PV1.class, true, false);
107 this.add(PV2.class, false, false);
108 this.add(ARV.class, false, true);
109 this.add(ROL.class, false, true);
110 this.add(DB1.class, false, true);
111 this.add(OBX.class, false, true);
112 this.add(AL1.class, false, true);
113 this.add(DG1.class, false, true);
114 this.add(DRG.class, false, false);
115 this.add(ADT_A06_PROCEDURE.class, false, true);
116 this.add(GT1.class, false, true);
117 this.add(ADT_A06_INSURANCE.class, false, true);
118 this.add(ACC.class, false, false);
119 this.add(UB1.class, false, false);
120 this.add(UB2.class, false, false);
121 } catch(HL7Exception e) {
122 log.error("Unexpected error creating ADT_A06 - this is probably a bug in the source code generator.", e);
123 }
124 }
125
126
127 /**
128 * Returns "2.8.1"
129 */
130 public String getVersion() {
131 return "2.8.1";
132 }
133
134
135
136
137 /**
138 * <p>
139 * Returns
140 * MSH (Message Header) - creates it if necessary
141 * </p>
142 *
143 *
144 */
145 public MSH getMSH() {
146 return getTyped("MSH", MSH.class);
147 }
148
149
150
151
152
153 /**
154 * <p>
155 * Returns
156 * the first repetition of
157 * SFT (Software Segment) - creates it if necessary
158 * </p>
159 *
160 *
161 */
162 public SFT getSFT() {
163 return getTyped("SFT", SFT.class);
164 }
165
166
167 /**
168 * <p>
169 * Returns a specific repetition of
170 * SFT (Software Segment) - creates it if necessary
171 * </p>
172 *
173 *
174 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
175 * @throws HL7Exception if the repetition requested is more than one
176 * greater than the number of existing repetitions.
177 */
178 public SFT getSFT(int rep) {
179 return getTyped("SFT", rep, SFT.class);
180 }
181
182 /**
183 * <p>
184 * Returns the number of existing repetitions of SFT
185 * </p>
186 *
187 */
188 public int getSFTReps() {
189 return getReps("SFT");
190 }
191
192 /**
193 * <p>
194 * Returns a non-modifiable List containing all current existing repetitions of SFT.
195 * <p>
196 * <p>
197 * Note that unlike {@link #getSFT()}, this method will not create any reps
198 * if none are already present, so an empty list may be returned.
199 * </p>
200 *
201 */
202 public java.util.List<SFT> getSFTAll() throws HL7Exception {
203 return getAllAsList("SFT", SFT.class);
204 }
205
206 /**
207 * <p>
208 * Inserts a specific repetition of SFT (Software Segment)
209 * </p>
210 *
211 *
212 * @see AbstractGroup#insertRepetition(Structure, int)
213 */
214 public void insertSFT(SFT structure, int rep) throws HL7Exception {
215 super.insertRepetition( "SFT", structure, rep);
216 }
217
218
219 /**
220 * <p>
221 * Inserts a specific repetition of SFT (Software Segment)
222 * </p>
223 *
224 *
225 * @see AbstractGroup#insertRepetition(Structure, int)
226 */
227 public SFT insertSFT(int rep) throws HL7Exception {
228 return (SFT)super.insertRepetition("SFT", rep);
229 }
230
231
232 /**
233 * <p>
234 * Removes a specific repetition of SFT (Software Segment)
235 * </p>
236 *
237 *
238 * @see AbstractGroup#removeRepetition(String, int)
239 */
240 public SFT removeSFT(int rep) throws HL7Exception {
241 return (SFT)super.removeRepetition("SFT", rep);
242 }
243
244
245
246
247 /**
248 * <p>
249 * Returns
250 * UAC (User Authentication Credential Segment) - creates it if necessary
251 * </p>
252 *
253 *
254 */
255 public UAC getUAC() {
256 return getTyped("UAC", UAC.class);
257 }
258
259
260
261
262
263 /**
264 * <p>
265 * Returns
266 * EVN (Event Type) - creates it if necessary
267 * </p>
268 *
269 *
270 */
271 public EVN getEVN() {
272 return getTyped("EVN", EVN.class);
273 }
274
275
276
277
278
279 /**
280 * <p>
281 * Returns
282 * PID (Patient Identification) - creates it if necessary
283 * </p>
284 *
285 *
286 */
287 public PID getPID() {
288 return getTyped("PID", PID.class);
289 }
290
291
292
293
294
295 /**
296 * <p>
297 * Returns
298 * PD1 (Patient Additional Demographic) - creates it if necessary
299 * </p>
300 *
301 *
302 */
303 public PD1 getPD1() {
304 return getTyped("PD1", PD1.class);
305 }
306
307
308
309
310
311 /**
312 * <p>
313 * Returns
314 * the first repetition of
315 * ARV (Access Restriction) - creates it if necessary
316 * </p>
317 *
318 *
319 */
320 public ARV getARV() {
321 return getTyped("ARV", ARV.class);
322 }
323
324
325 /**
326 * <p>
327 * Returns a specific repetition of
328 * ARV (Access Restriction) - creates it if necessary
329 * </p>
330 *
331 *
332 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
333 * @throws HL7Exception if the repetition requested is more than one
334 * greater than the number of existing repetitions.
335 */
336 public ARV getARV(int rep) {
337 return getTyped("ARV", rep, ARV.class);
338 }
339
340 /**
341 * <p>
342 * Returns the number of existing repetitions of ARV
343 * </p>
344 *
345 */
346 public int getARVReps() {
347 return getReps("ARV");
348 }
349
350 /**
351 * <p>
352 * Returns a non-modifiable List containing all current existing repetitions of ARV.
353 * <p>
354 * <p>
355 * Note that unlike {@link #getARV()}, this method will not create any reps
356 * if none are already present, so an empty list may be returned.
357 * </p>
358 *
359 */
360 public java.util.List<ARV> getARVAll() throws HL7Exception {
361 return getAllAsList("ARV", ARV.class);
362 }
363
364 /**
365 * <p>
366 * Inserts a specific repetition of ARV (Access Restriction)
367 * </p>
368 *
369 *
370 * @see AbstractGroup#insertRepetition(Structure, int)
371 */
372 public void insertARV(ARV structure, int rep) throws HL7Exception {
373 super.insertRepetition( "ARV", structure, rep);
374 }
375
376
377 /**
378 * <p>
379 * Inserts a specific repetition of ARV (Access Restriction)
380 * </p>
381 *
382 *
383 * @see AbstractGroup#insertRepetition(Structure, int)
384 */
385 public ARV insertARV(int rep) throws HL7Exception {
386 return (ARV)super.insertRepetition("ARV", rep);
387 }
388
389
390 /**
391 * <p>
392 * Removes a specific repetition of ARV (Access Restriction)
393 * </p>
394 *
395 *
396 * @see AbstractGroup#removeRepetition(String, int)
397 */
398 public ARV removeARV(int rep) throws HL7Exception {
399 return (ARV)super.removeRepetition("ARV", rep);
400 }
401
402
403
404
405 /**
406 * <p>
407 * Returns
408 * the first repetition of
409 * ROL (Role) - creates it if necessary
410 * </p>
411 *
412 *
413 */
414 public ROL getROL() {
415 return getTyped("ROL", ROL.class);
416 }
417
418
419 /**
420 * <p>
421 * Returns a specific repetition of
422 * ROL (Role) - creates it if necessary
423 * </p>
424 *
425 *
426 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
427 * @throws HL7Exception if the repetition requested is more than one
428 * greater than the number of existing repetitions.
429 */
430 public ROL getROL(int rep) {
431 return getTyped("ROL", rep, ROL.class);
432 }
433
434 /**
435 * <p>
436 * Returns the number of existing repetitions of ROL
437 * </p>
438 *
439 */
440 public int getROLReps() {
441 return getReps("ROL");
442 }
443
444 /**
445 * <p>
446 * Returns a non-modifiable List containing all current existing repetitions of ROL.
447 * <p>
448 * <p>
449 * Note that unlike {@link #getROL()}, this method will not create any reps
450 * if none are already present, so an empty list may be returned.
451 * </p>
452 *
453 */
454 public java.util.List<ROL> getROLAll() throws HL7Exception {
455 return getAllAsList("ROL", ROL.class);
456 }
457
458 /**
459 * <p>
460 * Inserts a specific repetition of ROL (Role)
461 * </p>
462 *
463 *
464 * @see AbstractGroup#insertRepetition(Structure, int)
465 */
466 public void insertROL(ROL structure, int rep) throws HL7Exception {
467 super.insertRepetition( "ROL", structure, rep);
468 }
469
470
471 /**
472 * <p>
473 * Inserts a specific repetition of ROL (Role)
474 * </p>
475 *
476 *
477 * @see AbstractGroup#insertRepetition(Structure, int)
478 */
479 public ROL insertROL(int rep) throws HL7Exception {
480 return (ROL)super.insertRepetition("ROL", rep);
481 }
482
483
484 /**
485 * <p>
486 * Removes a specific repetition of ROL (Role)
487 * </p>
488 *
489 *
490 * @see AbstractGroup#removeRepetition(String, int)
491 */
492 public ROL removeROL(int rep) throws HL7Exception {
493 return (ROL)super.removeRepetition("ROL", rep);
494 }
495
496
497
498
499 /**
500 * <p>
501 * Returns
502 * MRG (Merge Patient Information) - creates it if necessary
503 * </p>
504 *
505 *
506 */
507 public MRG getMRG() {
508 return getTyped("MRG", MRG.class);
509 }
510
511
512
513
514
515 /**
516 * <p>
517 * Returns
518 * the first repetition of
519 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
520 * </p>
521 *
522 *
523 */
524 public NK1 getNK1() {
525 return getTyped("NK1", NK1.class);
526 }
527
528
529 /**
530 * <p>
531 * Returns a specific repetition of
532 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
533 * </p>
534 *
535 *
536 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
537 * @throws HL7Exception if the repetition requested is more than one
538 * greater than the number of existing repetitions.
539 */
540 public NK1 getNK1(int rep) {
541 return getTyped("NK1", rep, NK1.class);
542 }
543
544 /**
545 * <p>
546 * Returns the number of existing repetitions of NK1
547 * </p>
548 *
549 */
550 public int getNK1Reps() {
551 return getReps("NK1");
552 }
553
554 /**
555 * <p>
556 * Returns a non-modifiable List containing all current existing repetitions of NK1.
557 * <p>
558 * <p>
559 * Note that unlike {@link #getNK1()}, this method will not create any reps
560 * if none are already present, so an empty list may be returned.
561 * </p>
562 *
563 */
564 public java.util.List<NK1> getNK1All() throws HL7Exception {
565 return getAllAsList("NK1", NK1.class);
566 }
567
568 /**
569 * <p>
570 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
571 * </p>
572 *
573 *
574 * @see AbstractGroup#insertRepetition(Structure, int)
575 */
576 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
577 super.insertRepetition( "NK1", structure, rep);
578 }
579
580
581 /**
582 * <p>
583 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
584 * </p>
585 *
586 *
587 * @see AbstractGroup#insertRepetition(Structure, int)
588 */
589 public NK1 insertNK1(int rep) throws HL7Exception {
590 return (NK1)super.insertRepetition("NK1", rep);
591 }
592
593
594 /**
595 * <p>
596 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties)
597 * </p>
598 *
599 *
600 * @see AbstractGroup#removeRepetition(String, int)
601 */
602 public NK1 removeNK1(int rep) throws HL7Exception {
603 return (NK1)super.removeRepetition("NK1", rep);
604 }
605
606
607
608
609 /**
610 * <p>
611 * Returns
612 * PV1 (Patient Visit) - creates it if necessary
613 * </p>
614 *
615 *
616 */
617 public PV1 getPV1() {
618 return getTyped("PV1", PV1.class);
619 }
620
621
622
623
624
625 /**
626 * <p>
627 * Returns
628 * PV2 (Patient Visit - Additional Information) - creates it if necessary
629 * </p>
630 *
631 *
632 */
633 public PV2 getPV2() {
634 return getTyped("PV2", PV2.class);
635 }
636
637
638
639
640
641 /**
642 * <p>
643 * Returns
644 * the first repetition of
645 * ARV2 (Access Restriction) - creates it if necessary
646 * </p>
647 *
648 *
649 */
650 public ARV getARV2() {
651 return getTyped("ARV2", ARV.class);
652 }
653
654
655 /**
656 * <p>
657 * Returns a specific repetition of
658 * ARV2 (Access Restriction) - creates it if necessary
659 * </p>
660 *
661 *
662 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
663 * @throws HL7Exception if the repetition requested is more than one
664 * greater than the number of existing repetitions.
665 */
666 public ARV getARV2(int rep) {
667 return getTyped("ARV2", rep, ARV.class);
668 }
669
670 /**
671 * <p>
672 * Returns the number of existing repetitions of ARV2
673 * </p>
674 *
675 */
676 public int getARV2Reps() {
677 return getReps("ARV2");
678 }
679
680 /**
681 * <p>
682 * Returns a non-modifiable List containing all current existing repetitions of ARV2.
683 * <p>
684 * <p>
685 * Note that unlike {@link #getARV2()}, this method will not create any reps
686 * if none are already present, so an empty list may be returned.
687 * </p>
688 *
689 */
690 public java.util.List<ARV> getARV2All() throws HL7Exception {
691 return getAllAsList("ARV2", ARV.class);
692 }
693
694 /**
695 * <p>
696 * Inserts a specific repetition of ARV2 (Access Restriction)
697 * </p>
698 *
699 *
700 * @see AbstractGroup#insertRepetition(Structure, int)
701 */
702 public void insertARV2(ARV structure, int rep) throws HL7Exception {
703 super.insertRepetition( "ARV2", structure, rep);
704 }
705
706
707 /**
708 * <p>
709 * Inserts a specific repetition of ARV2 (Access Restriction)
710 * </p>
711 *
712 *
713 * @see AbstractGroup#insertRepetition(Structure, int)
714 */
715 public ARV insertARV2(int rep) throws HL7Exception {
716 return (ARV)super.insertRepetition("ARV2", rep);
717 }
718
719
720 /**
721 * <p>
722 * Removes a specific repetition of ARV2 (Access Restriction)
723 * </p>
724 *
725 *
726 * @see AbstractGroup#removeRepetition(String, int)
727 */
728 public ARV removeARV2(int rep) throws HL7Exception {
729 return (ARV)super.removeRepetition("ARV2", rep);
730 }
731
732
733
734
735 /**
736 * <p>
737 * Returns
738 * the first repetition of
739 * ROL2 (Role) - creates it if necessary
740 * </p>
741 *
742 *
743 */
744 public ROL getROL2() {
745 return getTyped("ROL2", ROL.class);
746 }
747
748
749 /**
750 * <p>
751 * Returns a specific repetition of
752 * ROL2 (Role) - creates it if necessary
753 * </p>
754 *
755 *
756 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
757 * @throws HL7Exception if the repetition requested is more than one
758 * greater than the number of existing repetitions.
759 */
760 public ROL getROL2(int rep) {
761 return getTyped("ROL2", rep, ROL.class);
762 }
763
764 /**
765 * <p>
766 * Returns the number of existing repetitions of ROL2
767 * </p>
768 *
769 */
770 public int getROL2Reps() {
771 return getReps("ROL2");
772 }
773
774 /**
775 * <p>
776 * Returns a non-modifiable List containing all current existing repetitions of ROL2.
777 * <p>
778 * <p>
779 * Note that unlike {@link #getROL2()}, this method will not create any reps
780 * if none are already present, so an empty list may be returned.
781 * </p>
782 *
783 */
784 public java.util.List<ROL> getROL2All() throws HL7Exception {
785 return getAllAsList("ROL2", ROL.class);
786 }
787
788 /**
789 * <p>
790 * Inserts a specific repetition of ROL2 (Role)
791 * </p>
792 *
793 *
794 * @see AbstractGroup#insertRepetition(Structure, int)
795 */
796 public void insertROL2(ROL structure, int rep) throws HL7Exception {
797 super.insertRepetition( "ROL2", structure, rep);
798 }
799
800
801 /**
802 * <p>
803 * Inserts a specific repetition of ROL2 (Role)
804 * </p>
805 *
806 *
807 * @see AbstractGroup#insertRepetition(Structure, int)
808 */
809 public ROL insertROL2(int rep) throws HL7Exception {
810 return (ROL)super.insertRepetition("ROL2", rep);
811 }
812
813
814 /**
815 * <p>
816 * Removes a specific repetition of ROL2 (Role)
817 * </p>
818 *
819 *
820 * @see AbstractGroup#removeRepetition(String, int)
821 */
822 public ROL removeROL2(int rep) throws HL7Exception {
823 return (ROL)super.removeRepetition("ROL2", rep);
824 }
825
826
827
828
829 /**
830 * <p>
831 * Returns
832 * the first repetition of
833 * DB1 (Disability) - creates it if necessary
834 * </p>
835 *
836 *
837 */
838 public DB1 getDB1() {
839 return getTyped("DB1", DB1.class);
840 }
841
842
843 /**
844 * <p>
845 * Returns a specific repetition of
846 * DB1 (Disability) - creates it if necessary
847 * </p>
848 *
849 *
850 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
851 * @throws HL7Exception if the repetition requested is more than one
852 * greater than the number of existing repetitions.
853 */
854 public DB1 getDB1(int rep) {
855 return getTyped("DB1", rep, DB1.class);
856 }
857
858 /**
859 * <p>
860 * Returns the number of existing repetitions of DB1
861 * </p>
862 *
863 */
864 public int getDB1Reps() {
865 return getReps("DB1");
866 }
867
868 /**
869 * <p>
870 * Returns a non-modifiable List containing all current existing repetitions of DB1.
871 * <p>
872 * <p>
873 * Note that unlike {@link #getDB1()}, this method will not create any reps
874 * if none are already present, so an empty list may be returned.
875 * </p>
876 *
877 */
878 public java.util.List<DB1> getDB1All() throws HL7Exception {
879 return getAllAsList("DB1", DB1.class);
880 }
881
882 /**
883 * <p>
884 * Inserts a specific repetition of DB1 (Disability)
885 * </p>
886 *
887 *
888 * @see AbstractGroup#insertRepetition(Structure, int)
889 */
890 public void insertDB1(DB1 structure, int rep) throws HL7Exception {
891 super.insertRepetition( "DB1", structure, rep);
892 }
893
894
895 /**
896 * <p>
897 * Inserts a specific repetition of DB1 (Disability)
898 * </p>
899 *
900 *
901 * @see AbstractGroup#insertRepetition(Structure, int)
902 */
903 public DB1 insertDB1(int rep) throws HL7Exception {
904 return (DB1)super.insertRepetition("DB1", rep);
905 }
906
907
908 /**
909 * <p>
910 * Removes a specific repetition of DB1 (Disability)
911 * </p>
912 *
913 *
914 * @see AbstractGroup#removeRepetition(String, int)
915 */
916 public DB1 removeDB1(int rep) throws HL7Exception {
917 return (DB1)super.removeRepetition("DB1", rep);
918 }
919
920
921
922
923 /**
924 * <p>
925 * Returns
926 * the first repetition of
927 * OBX (Observation/Result) - creates it if necessary
928 * </p>
929 *
930 *
931 */
932 public OBX getOBX() {
933 return getTyped("OBX", OBX.class);
934 }
935
936
937 /**
938 * <p>
939 * Returns a specific repetition of
940 * OBX (Observation/Result) - creates it if necessary
941 * </p>
942 *
943 *
944 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
945 * @throws HL7Exception if the repetition requested is more than one
946 * greater than the number of existing repetitions.
947 */
948 public OBX getOBX(int rep) {
949 return getTyped("OBX", rep, OBX.class);
950 }
951
952 /**
953 * <p>
954 * Returns the number of existing repetitions of OBX
955 * </p>
956 *
957 */
958 public int getOBXReps() {
959 return getReps("OBX");
960 }
961
962 /**
963 * <p>
964 * Returns a non-modifiable List containing all current existing repetitions of OBX.
965 * <p>
966 * <p>
967 * Note that unlike {@link #getOBX()}, this method will not create any reps
968 * if none are already present, so an empty list may be returned.
969 * </p>
970 *
971 */
972 public java.util.List<OBX> getOBXAll() throws HL7Exception {
973 return getAllAsList("OBX", OBX.class);
974 }
975
976 /**
977 * <p>
978 * Inserts a specific repetition of OBX (Observation/Result)
979 * </p>
980 *
981 *
982 * @see AbstractGroup#insertRepetition(Structure, int)
983 */
984 public void insertOBX(OBX structure, int rep) throws HL7Exception {
985 super.insertRepetition( "OBX", structure, rep);
986 }
987
988
989 /**
990 * <p>
991 * Inserts a specific repetition of OBX (Observation/Result)
992 * </p>
993 *
994 *
995 * @see AbstractGroup#insertRepetition(Structure, int)
996 */
997 public OBX insertOBX(int rep) throws HL7Exception {
998 return (OBX)super.insertRepetition("OBX", rep);
999 }
1000
1001
1002 /**
1003 * <p>
1004 * Removes a specific repetition of OBX (Observation/Result)
1005 * </p>
1006 *
1007 *
1008 * @see AbstractGroup#removeRepetition(String, int)
1009 */
1010 public OBX removeOBX(int rep) throws HL7Exception {
1011 return (OBX)super.removeRepetition("OBX", rep);
1012 }
1013
1014
1015
1016
1017 /**
1018 * <p>
1019 * Returns
1020 * the first repetition of
1021 * AL1 (Patient Allergy Information) - creates it if necessary
1022 * </p>
1023 *
1024 *
1025 */
1026 public AL1 getAL1() {
1027 return getTyped("AL1", AL1.class);
1028 }
1029
1030
1031 /**
1032 * <p>
1033 * Returns a specific repetition of
1034 * AL1 (Patient Allergy Information) - creates it if necessary
1035 * </p>
1036 *
1037 *
1038 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1039 * @throws HL7Exception if the repetition requested is more than one
1040 * greater than the number of existing repetitions.
1041 */
1042 public AL1 getAL1(int rep) {
1043 return getTyped("AL1", rep, AL1.class);
1044 }
1045
1046 /**
1047 * <p>
1048 * Returns the number of existing repetitions of AL1
1049 * </p>
1050 *
1051 */
1052 public int getAL1Reps() {
1053 return getReps("AL1");
1054 }
1055
1056 /**
1057 * <p>
1058 * Returns a non-modifiable List containing all current existing repetitions of AL1.
1059 * <p>
1060 * <p>
1061 * Note that unlike {@link #getAL1()}, this method will not create any reps
1062 * if none are already present, so an empty list may be returned.
1063 * </p>
1064 *
1065 */
1066 public java.util.List<AL1> getAL1All() throws HL7Exception {
1067 return getAllAsList("AL1", AL1.class);
1068 }
1069
1070 /**
1071 * <p>
1072 * Inserts a specific repetition of AL1 (Patient Allergy Information)
1073 * </p>
1074 *
1075 *
1076 * @see AbstractGroup#insertRepetition(Structure, int)
1077 */
1078 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
1079 super.insertRepetition( "AL1", structure, rep);
1080 }
1081
1082
1083 /**
1084 * <p>
1085 * Inserts a specific repetition of AL1 (Patient Allergy Information)
1086 * </p>
1087 *
1088 *
1089 * @see AbstractGroup#insertRepetition(Structure, int)
1090 */
1091 public AL1 insertAL1(int rep) throws HL7Exception {
1092 return (AL1)super.insertRepetition("AL1", rep);
1093 }
1094
1095
1096 /**
1097 * <p>
1098 * Removes a specific repetition of AL1 (Patient Allergy Information)
1099 * </p>
1100 *
1101 *
1102 * @see AbstractGroup#removeRepetition(String, int)
1103 */
1104 public AL1 removeAL1(int rep) throws HL7Exception {
1105 return (AL1)super.removeRepetition("AL1", rep);
1106 }
1107
1108
1109
1110
1111 /**
1112 * <p>
1113 * Returns
1114 * the first repetition of
1115 * DG1 (Diagnosis) - creates it if necessary
1116 * </p>
1117 *
1118 *
1119 */
1120 public DG1 getDG1() {
1121 return getTyped("DG1", DG1.class);
1122 }
1123
1124
1125 /**
1126 * <p>
1127 * Returns a specific repetition of
1128 * DG1 (Diagnosis) - creates it if necessary
1129 * </p>
1130 *
1131 *
1132 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1133 * @throws HL7Exception if the repetition requested is more than one
1134 * greater than the number of existing repetitions.
1135 */
1136 public DG1 getDG1(int rep) {
1137 return getTyped("DG1", rep, DG1.class);
1138 }
1139
1140 /**
1141 * <p>
1142 * Returns the number of existing repetitions of DG1
1143 * </p>
1144 *
1145 */
1146 public int getDG1Reps() {
1147 return getReps("DG1");
1148 }
1149
1150 /**
1151 * <p>
1152 * Returns a non-modifiable List containing all current existing repetitions of DG1.
1153 * <p>
1154 * <p>
1155 * Note that unlike {@link #getDG1()}, this method will not create any reps
1156 * if none are already present, so an empty list may be returned.
1157 * </p>
1158 *
1159 */
1160 public java.util.List<DG1> getDG1All() throws HL7Exception {
1161 return getAllAsList("DG1", DG1.class);
1162 }
1163
1164 /**
1165 * <p>
1166 * Inserts a specific repetition of DG1 (Diagnosis)
1167 * </p>
1168 *
1169 *
1170 * @see AbstractGroup#insertRepetition(Structure, int)
1171 */
1172 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
1173 super.insertRepetition( "DG1", structure, rep);
1174 }
1175
1176
1177 /**
1178 * <p>
1179 * Inserts a specific repetition of DG1 (Diagnosis)
1180 * </p>
1181 *
1182 *
1183 * @see AbstractGroup#insertRepetition(Structure, int)
1184 */
1185 public DG1 insertDG1(int rep) throws HL7Exception {
1186 return (DG1)super.insertRepetition("DG1", rep);
1187 }
1188
1189
1190 /**
1191 * <p>
1192 * Removes a specific repetition of DG1 (Diagnosis)
1193 * </p>
1194 *
1195 *
1196 * @see AbstractGroup#removeRepetition(String, int)
1197 */
1198 public DG1 removeDG1(int rep) throws HL7Exception {
1199 return (DG1)super.removeRepetition("DG1", rep);
1200 }
1201
1202
1203
1204
1205 /**
1206 * <p>
1207 * Returns
1208 * DRG (Diagnosis Related Group) - creates it if necessary
1209 * </p>
1210 *
1211 *
1212 */
1213 public DRG getDRG() {
1214 return getTyped("DRG", DRG.class);
1215 }
1216
1217
1218
1219
1220
1221 /**
1222 * <p>
1223 * Returns
1224 * the first repetition of
1225 * PROCEDURE (a Group object) - creates it if necessary
1226 * </p>
1227 *
1228 *
1229 */
1230 public ADT_A06_PROCEDURE getPROCEDURE() {
1231 return getTyped("PROCEDURE", ADT_A06_PROCEDURE.class);
1232 }
1233
1234
1235 /**
1236 * <p>
1237 * Returns a specific repetition of
1238 * PROCEDURE (a Group object) - creates it if necessary
1239 * </p>
1240 *
1241 *
1242 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1243 * @throws HL7Exception if the repetition requested is more than one
1244 * greater than the number of existing repetitions.
1245 */
1246 public ADT_A06_PROCEDURE getPROCEDURE(int rep) {
1247 return getTyped("PROCEDURE", rep, ADT_A06_PROCEDURE.class);
1248 }
1249
1250 /**
1251 * <p>
1252 * Returns the number of existing repetitions of PROCEDURE
1253 * </p>
1254 *
1255 */
1256 public int getPROCEDUREReps() {
1257 return getReps("PROCEDURE");
1258 }
1259
1260 /**
1261 * <p>
1262 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
1263 * <p>
1264 * <p>
1265 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
1266 * if none are already present, so an empty list may be returned.
1267 * </p>
1268 *
1269 */
1270 public java.util.List<ADT_A06_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
1271 return getAllAsList("PROCEDURE", ADT_A06_PROCEDURE.class);
1272 }
1273
1274 /**
1275 * <p>
1276 * Inserts a specific repetition of PROCEDURE (a Group object)
1277 * </p>
1278 *
1279 *
1280 * @see AbstractGroup#insertRepetition(Structure, int)
1281 */
1282 public void insertPROCEDURE(ADT_A06_PROCEDURE structure, int rep) throws HL7Exception {
1283 super.insertRepetition( "PROCEDURE", structure, rep);
1284 }
1285
1286
1287 /**
1288 * <p>
1289 * Inserts a specific repetition of PROCEDURE (a Group object)
1290 * </p>
1291 *
1292 *
1293 * @see AbstractGroup#insertRepetition(Structure, int)
1294 */
1295 public ADT_A06_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
1296 return (ADT_A06_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
1297 }
1298
1299
1300 /**
1301 * <p>
1302 * Removes a specific repetition of PROCEDURE (a Group object)
1303 * </p>
1304 *
1305 *
1306 * @see AbstractGroup#removeRepetition(String, int)
1307 */
1308 public ADT_A06_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
1309 return (ADT_A06_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
1310 }
1311
1312
1313
1314
1315 /**
1316 * <p>
1317 * Returns
1318 * the first repetition of
1319 * GT1 (Guarantor) - creates it if necessary
1320 * </p>
1321 *
1322 *
1323 */
1324 public GT1 getGT1() {
1325 return getTyped("GT1", GT1.class);
1326 }
1327
1328
1329 /**
1330 * <p>
1331 * Returns a specific repetition of
1332 * GT1 (Guarantor) - creates it if necessary
1333 * </p>
1334 *
1335 *
1336 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1337 * @throws HL7Exception if the repetition requested is more than one
1338 * greater than the number of existing repetitions.
1339 */
1340 public GT1 getGT1(int rep) {
1341 return getTyped("GT1", rep, GT1.class);
1342 }
1343
1344 /**
1345 * <p>
1346 * Returns the number of existing repetitions of GT1
1347 * </p>
1348 *
1349 */
1350 public int getGT1Reps() {
1351 return getReps("GT1");
1352 }
1353
1354 /**
1355 * <p>
1356 * Returns a non-modifiable List containing all current existing repetitions of GT1.
1357 * <p>
1358 * <p>
1359 * Note that unlike {@link #getGT1()}, this method will not create any reps
1360 * if none are already present, so an empty list may be returned.
1361 * </p>
1362 *
1363 */
1364 public java.util.List<GT1> getGT1All() throws HL7Exception {
1365 return getAllAsList("GT1", GT1.class);
1366 }
1367
1368 /**
1369 * <p>
1370 * Inserts a specific repetition of GT1 (Guarantor)
1371 * </p>
1372 *
1373 *
1374 * @see AbstractGroup#insertRepetition(Structure, int)
1375 */
1376 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
1377 super.insertRepetition( "GT1", structure, rep);
1378 }
1379
1380
1381 /**
1382 * <p>
1383 * Inserts a specific repetition of GT1 (Guarantor)
1384 * </p>
1385 *
1386 *
1387 * @see AbstractGroup#insertRepetition(Structure, int)
1388 */
1389 public GT1 insertGT1(int rep) throws HL7Exception {
1390 return (GT1)super.insertRepetition("GT1", rep);
1391 }
1392
1393
1394 /**
1395 * <p>
1396 * Removes a specific repetition of GT1 (Guarantor)
1397 * </p>
1398 *
1399 *
1400 * @see AbstractGroup#removeRepetition(String, int)
1401 */
1402 public GT1 removeGT1(int rep) throws HL7Exception {
1403 return (GT1)super.removeRepetition("GT1", rep);
1404 }
1405
1406
1407
1408
1409 /**
1410 * <p>
1411 * Returns
1412 * the first repetition of
1413 * INSURANCE (a Group object) - creates it if necessary
1414 * </p>
1415 *
1416 *
1417 */
1418 public ADT_A06_INSURANCE getINSURANCE() {
1419 return getTyped("INSURANCE", ADT_A06_INSURANCE.class);
1420 }
1421
1422
1423 /**
1424 * <p>
1425 * Returns a specific repetition of
1426 * INSURANCE (a Group object) - creates it if necessary
1427 * </p>
1428 *
1429 *
1430 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1431 * @throws HL7Exception if the repetition requested is more than one
1432 * greater than the number of existing repetitions.
1433 */
1434 public ADT_A06_INSURANCE getINSURANCE(int rep) {
1435 return getTyped("INSURANCE", rep, ADT_A06_INSURANCE.class);
1436 }
1437
1438 /**
1439 * <p>
1440 * Returns the number of existing repetitions of INSURANCE
1441 * </p>
1442 *
1443 */
1444 public int getINSURANCEReps() {
1445 return getReps("INSURANCE");
1446 }
1447
1448 /**
1449 * <p>
1450 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
1451 * <p>
1452 * <p>
1453 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
1454 * if none are already present, so an empty list may be returned.
1455 * </p>
1456 *
1457 */
1458 public java.util.List<ADT_A06_INSURANCE> getINSURANCEAll() throws HL7Exception {
1459 return getAllAsList("INSURANCE", ADT_A06_INSURANCE.class);
1460 }
1461
1462 /**
1463 * <p>
1464 * Inserts a specific repetition of INSURANCE (a Group object)
1465 * </p>
1466 *
1467 *
1468 * @see AbstractGroup#insertRepetition(Structure, int)
1469 */
1470 public void insertINSURANCE(ADT_A06_INSURANCE structure, int rep) throws HL7Exception {
1471 super.insertRepetition( "INSURANCE", structure, rep);
1472 }
1473
1474
1475 /**
1476 * <p>
1477 * Inserts a specific repetition of INSURANCE (a Group object)
1478 * </p>
1479 *
1480 *
1481 * @see AbstractGroup#insertRepetition(Structure, int)
1482 */
1483 public ADT_A06_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
1484 return (ADT_A06_INSURANCE)super.insertRepetition("INSURANCE", rep);
1485 }
1486
1487
1488 /**
1489 * <p>
1490 * Removes a specific repetition of INSURANCE (a Group object)
1491 * </p>
1492 *
1493 *
1494 * @see AbstractGroup#removeRepetition(String, int)
1495 */
1496 public ADT_A06_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
1497 return (ADT_A06_INSURANCE)super.removeRepetition("INSURANCE", rep);
1498 }
1499
1500
1501
1502
1503 /**
1504 * <p>
1505 * Returns
1506 * ACC (Accident) - creates it if necessary
1507 * </p>
1508 *
1509 *
1510 */
1511 public ACC getACC() {
1512 return getTyped("ACC", ACC.class);
1513 }
1514
1515
1516
1517
1518
1519 /**
1520 * <p>
1521 * Returns
1522 * UB1 () - creates it if necessary
1523 * </p>
1524 *
1525 *
1526 */
1527 public UB1 getUB1() {
1528 return getTyped("UB1", UB1.class);
1529 }
1530
1531
1532
1533
1534
1535 /**
1536 * <p>
1537 * Returns
1538 * UB2 (Uniform Billing Data) - creates it if necessary
1539 * </p>
1540 *
1541 *
1542 */
1543 public UB2 getUB2() {
1544 return getTyped("UB2", UB2.class);
1545 }
1546
1547
1548
1549
1550 }
1551