001/*
002 * This class is an auto-generated source file for a HAPI
003 * HL7 v2.x standard structure class.
004 *
005 * For more information, visit: http://hl7api.sourceforge.net/
006 * 
007 * The contents of this file are subject to the Mozilla Public License Version 1.1 
008 * (the "License"); you may not use this file except in compliance with the License. 
009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
010 * Software distributed under the License is distributed on an "AS IS" basis, 
011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
012 * specific language governing rights and limitations under the License. 
013 * 
014 * The Original Code is "[file_name]".  Description: 
015 * "[one_line_description]" 
016 * 
017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
018 * 2012.  All Rights Reserved. 
019 * 
020 * Contributor(s): ______________________________________. 
021 * 
022 * Alternatively, the contents of this file may be used under the terms of the 
023 * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
024 * applicable instead of those above.  If you wish to allow use of your version of this 
025 * file only under the terms of the GPL and not to allow others to use your version 
026 * of this file under the MPL, indicate your decision by deleting  the provisions above 
027 * and replace  them with the notice and other provisions required by the GPL License.  
028 * If you do not delete the provisions above, a recipient may use your version of 
029 * this file under either the MPL or the GPL. 
030 * 
031 */
032
033
034package ca.uhn.hl7v2.model.v22.message;
035
036import ca.uhn.hl7v2.model.v22.group.*;
037import ca.uhn.hl7v2.model.v22.segment.*;
038
039import ca.uhn.hl7v2.HL7Exception;
040import ca.uhn.hl7v2.parser.ModelClassFactory;
041import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
042import ca.uhn.hl7v2.model.*;
043
044
045/**
046 * <p>Represents a ADT_A07 message structure (see chapter ?). This structure contains the 
047 * following elements: </p>
048 * <ul>
049                                 * <li>1: MSH (MESSAGE HEADER) <b> </b> </li>
050                                 * <li>2: EVN (EVENT TYPE) <b> </b> </li>
051                                 * <li>3: PID (PATIENT IDENTIFICATION) <b> </b> </li>
052                                 * <li>4: MRG (MERGE PATIENT INFORMATION) <b>optional </b> </li>
053                                 * <li>5: NK1 (NEXT OF KIN) <b>optional repeating</b> </li>
054                                 * <li>6: PV1 (PATIENT VISIT) <b> </b> </li>
055                                 * <li>7: PV2 (PATIENT VISIT - additional information) <b>optional </b> </li>
056                                 * <li>8: OBX (OBSERVATION RESULT) <b>optional repeating</b> </li>
057                                 * <li>9: AL1 (PATIENT ALLERGY INFORMATION) <b>optional repeating</b> </li>
058                                 * <li>10: DG1 (DIAGNOSIS) <b>optional repeating</b> </li>
059                                 * <li>11: PR1 (PROCEDURES) <b>optional repeating</b> </li>
060                                 * <li>12: GT1 (GUARANTOR) <b>optional repeating</b> </li>
061                                 * <li>13: ADT_A07_INSURANCE (a Group object) <b>optional repeating</b> </li>
062                                 * <li>14: ACC (ACCIDENT) <b>optional </b> </li>
063                                 * <li>15: UB1 (UB82 DATA) <b>optional </b> </li>
064                                 * <li>16: UB2 (UB92 DATA) <b>optional </b> </li>
065 * </ul>
066 */
067//@SuppressWarnings("unused")
068public class ADT_A07 extends AbstractMessage  {
069
070    /**
071     * Creates a new ADT_A07 message with DefaultModelClassFactory. 
072     */ 
073    public ADT_A07() { 
074       this(new DefaultModelClassFactory());
075    }
076
077    /** 
078     * Creates a new ADT_A07 message with custom ModelClassFactory.
079     */
080    public ADT_A07(ModelClassFactory factory) {
081       super(factory);
082       init(factory);
083    }
084
085    private void init(ModelClassFactory factory) {
086       try {
087                          this.add(MSH.class, true, false);
088                                  this.add(EVN.class, true, false);
089                                  this.add(PID.class, true, false);
090                                  this.add(MRG.class, false, false);
091                                  this.add(NK1.class, false, true);
092                                  this.add(PV1.class, true, false);
093                                  this.add(PV2.class, false, false);
094                                  this.add(OBX.class, false, true);
095                                  this.add(AL1.class, false, true);
096                                  this.add(DG1.class, false, true);
097                                  this.add(PR1.class, false, true);
098                                  this.add(GT1.class, false, true);
099                                  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