View Javadoc
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.segment;
35  
36  // import ca.uhn.hl7v2.model.v22.group.*;
37  import ca.uhn.hl7v2.model.v22.datatype.*;
38  import ca.uhn.hl7v2.HL7Exception;
39  import ca.uhn.hl7v2.parser.ModelClassFactory;
40  import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
41  import ca.uhn.hl7v2.model.AbstractMessage;
42  import ca.uhn.hl7v2.model.Group;
43  import ca.uhn.hl7v2.model.Type;
44  import ca.uhn.hl7v2.model.AbstractSegment;
45  import ca.uhn.hl7v2.model.Varies;
46  
47  
48  /**
49   *<p>Represents an HL7 OM1 message segment (GENERAL - fields that apply to most observations). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>OM1-1: Segment Type ID (ST) <b>optional </b>
53       * <li>OM1-2: Sequence Number - Test/ Observation Master File (NM) <b>optional </b>
54       * <li>OM1-3: Producer's test / observation ID (CE) <b> </b>
55       * <li>OM1-4: Permitted Data Types (ID) <b>optional repeating</b>
56       * <li>OM1-5: Specimen Required (ID) <b> </b>
57       * <li>OM1-6: Producer ID (CE) <b> </b>
58       * <li>OM1-7: Observation Description (TX) <b>optional </b>
59       * <li>OM1-8: Other test / observation IDs for the observation (CE) <b>optional </b>
60       * <li>OM1-9: Other Names (ST) <b> repeating</b>
61       * <li>OM1-10: Preferred Report Name for the Observation (ST) <b>optional </b>
62       * <li>OM1-11: Preferred Short Name or Mnemonic for Observation (ST) <b>optional </b>
63       * <li>OM1-12: Preferred Long Name for the Observation (ST) <b>optional </b>
64       * <li>OM1-13: Orderability (ID) <b>optional </b>
65       * <li>OM1-14: Identity of instrument used to perform this study (CE) <b>optional repeating</b>
66       * <li>OM1-15: Coded Representation of Method (CE) <b>optional repeating</b>
67       * <li>OM1-16: Portable (ID) <b>optional </b>
68       * <li>OM1-17: Observation producing department / section (ID) <b>optional repeating</b>
69       * <li>OM1-18: Telephone Number of Section (TN) <b>optional </b>
70       * <li>OM1-19: Nature of test / observation (ID) <b> </b>
71       * <li>OM1-20: Report Subheader (CE) <b>optional </b>
72       * <li>OM1-21: Report Display Order (ST) <b>optional </b>
73       * <li>OM1-22: Date / time stamp for any change in definition for obs (TS) <b> </b>
74       * <li>OM1-23: Effective date / time of change (TS) <b>optional </b>
75       * <li>OM1-24: Typical Turn-around Time (NM) <b>optional </b>
76       * <li>OM1-25: Processing Time (NM) <b>optional </b>
77       * <li>OM1-26: Processing Priority (ID) <b>optional repeating</b>
78       * <li>OM1-27: Reporting Priority (ID) <b>optional </b>
79       * <li>OM1-28: Outside Site(s) Where Observation may be Performed (CE) <b>optional repeating</b>
80       * <li>OM1-29: Address of Outside Site(s) (AD) <b>optional repeating</b>
81       * <li>OM1-30: Phone Number of Outside Site (TN) <b>optional repeating</b>
82       * <li>OM1-31: Confidentiality Code (ID) <b>optional </b>
83       * <li>OM1-32: Observations required to interpret the observation (CE) <b>optional repeating</b>
84       * <li>OM1-33: Interpretation of Observations (TX) <b>optional </b>
85       * <li>OM1-34: Contraindications to Observations (CE) <b>optional repeating</b>
86       * <li>OM1-35: Reflex tests / observations (CE) <b>optional repeating</b>
87       * <li>OM1-36: Rules that Trigger Reflex Testing (ST) <b>optional </b>
88       * <li>OM1-37: Fixed Canned Message (CE) <b>optional repeating</b>
89       * <li>OM1-38: Patient Preparation (TX) <b>optional </b>
90       * <li>OM1-39: Procedure Medication (CE) <b>optional </b>
91       * <li>OM1-40: Factors that may affect the observation (TX) <b>optional </b>
92       * <li>OM1-41: Test / observation performance schedule (ST) <b>optional repeating</b>
93       * <li>OM1-42: Description of Test Methods (TX) <b>optional </b>
94   * </ul>
95   */
96  @SuppressWarnings("unused")
97  public class OM1 extends AbstractSegment {
98  
99      /** 
100      * Creates a new OM1 segment
101      */
102     public OM1(Group parent, ModelClassFactory factory) {
103        super(parent, factory);
104        init(factory);
105     }
106 
107     private void init(ModelClassFactory factory) {
108        try {
109                                   this.add(ST.class, false, 1, 3, new Object[]{ getMessage() }, "Segment Type ID");
110                                   this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Sequence Number - Test/ Observation Master File");
111                                   this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer's test / observation ID");
112                                               this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(125) }, "Permitted Data Types");
113                                               this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Specimen Required");
114                                   this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer ID");
115                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Observation Description");
116                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Other test / observation IDs for the observation");
117                                   this.add(ST.class, true, 0, 200, new Object[]{ getMessage() }, "Other Names");
118                                   this.add(ST.class, false, 1, 30, new Object[]{ getMessage() }, "Preferred Report Name for the Observation");
119                                   this.add(ST.class, false, 1, 8, new Object[]{ getMessage() }, "Preferred Short Name or Mnemonic for Observation");
120                                   this.add(ST.class, false, 1, 200, new Object[]{ getMessage() }, "Preferred Long Name for the Observation");
121                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Orderability");
122                                   this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Identity of instrument used to perform this study");
123                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Coded Representation of Method");
124                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Portable");
125                                               this.add(ID.class, false, 0, 1, new Object[]{ getMessage(), new Integer(0) }, "Observation producing department / section");
126                                   this.add(TN.class, false, 1, 40, new Object[]{ getMessage() }, "Telephone Number of Section");
127                                               this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(174) }, "Nature of test / observation");
128                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Report Subheader");
129                                   this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Report Display Order");
130                                   this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Date / time stamp for any change in definition for obs");
131                                   this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective date / time of change");
132                                   this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Typical Turn-around Time");
133                                   this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Processing Time");
134                                               this.add(ID.class, false, 0, 40, new Object[]{ getMessage(), new Integer(168) }, "Processing Priority");
135                                               this.add(ID.class, false, 1, 5, new Object[]{ getMessage(), new Integer(169) }, "Reporting Priority");
136                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Outside Site(s) Where Observation may be Performed");
137                                   this.add(AD.class, false, 0, 1000, new Object[]{ getMessage() }, "Address of Outside Site(s)");
138                                   this.add(TN.class, false, 0, 400, new Object[]{ getMessage() }, "Phone Number of Outside Site");
139                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(177) }, "Confidentiality Code");
140                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Observations required to interpret the observation");
141                                   this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Interpretation of Observations");
142                                   this.add(CE.class, false, 0, 65536, new Object[]{ getMessage() }, "Contraindications to Observations");
143                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Reflex tests / observations");
144                                   this.add(ST.class, false, 1, 80, new Object[]{ getMessage() }, "Rules that Trigger Reflex Testing");
145                                   this.add(CE.class, false, 0, 65536, new Object[]{ getMessage() }, "Fixed Canned Message");
146                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Patient Preparation");
147                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Procedure Medication");
148                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Factors that may affect the observation");
149                                   this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Test / observation performance schedule");
150                                   this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Description of Test Methods");
151        } catch(HL7Exception e) {
152           log.error("Unexpected error creating OM1 - this is probably a bug in the source code generator.", e);
153        }
154     }
155 
156 
157 
158     /**
159      * Returns
160      * OM1-1: "Segment Type ID" - creates it if necessary
161      */
162     public ST getSegmentTypeID() { 
163 		ST retVal = this.getTypedField(1, 0);
164 		return retVal;
165     }
166     
167     /**
168      * Returns
169      * OM1-1: "Segment Type ID" - creates it if necessary
170      */
171     public ST getOm11_SegmentTypeID() { 
172 		ST retVal = this.getTypedField(1, 0);
173 		return retVal;
174     }
175 
176 
177 
178     /**
179      * Returns
180      * OM1-2: "Sequence Number - Test/ Observation Master File" - creates it if necessary
181      */
182     public NM getSequenceNumberTestObservationMasterFile() { 
183 		NM retVal = this.getTypedField(2, 0);
184 		return retVal;
185     }
186     
187     /**
188      * Returns
189      * OM1-2: "Sequence Number - Test/ Observation Master File" - creates it if necessary
190      */
191     public NM getOm12_SequenceNumberTestObservationMasterFile() { 
192 		NM retVal = this.getTypedField(2, 0);
193 		return retVal;
194     }
195 
196 
197 
198     /**
199      * Returns
200      * OM1-3: "Producer's test / observation ID" - creates it if necessary
201      */
202     public CE getProducerSTestObservationID() { 
203 		CE retVal = this.getTypedField(3, 0);
204 		return retVal;
205     }
206     
207     /**
208      * Returns
209      * OM1-3: "Producer's test / observation ID" - creates it if necessary
210      */
211     public CE getOm13_ProducerSTestObservationID() { 
212 		CE retVal = this.getTypedField(3, 0);
213 		return retVal;
214     }
215 
216 
217     /**
218      * Returns all repetitions of Permitted Data Types (OM1-4).
219      */
220     public ID[] getPermittedDataTypes() {
221     	ID[] retVal = this.getTypedField(4, new ID[0]);
222     	return retVal;
223     }
224 
225 
226     /**
227      * Returns all repetitions of Permitted Data Types (OM1-4).
228      */
229     public ID[] getOm14_PermittedDataTypes() {
230     	ID[] retVal = this.getTypedField(4, new ID[0]);
231     	return retVal;
232     }
233 
234 
235     /**
236      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-4).
237      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
238      * it will return zero.
239      */
240     public int getPermittedDataTypesReps() {
241     	return this.getReps(4);
242     }
243 
244 
245     /**
246      * Returns a specific repetition of
247      * OM1-4: "Permitted Data Types" - creates it if necessary
248      *
249      * @param rep The repetition index (0-indexed)
250      */
251     public ID getPermittedDataTypes(int rep) { 
252 		ID retVal = this.getTypedField(4, rep);
253 		return retVal;
254     }
255 
256     /**
257      * Returns a specific repetition of
258      * OM1-4: "Permitted Data Types" - creates it if necessary
259      *
260      * @param rep The repetition index (0-indexed)
261      */
262     public ID getOm14_PermittedDataTypes(int rep) { 
263 		ID retVal = this.getTypedField(4, rep);
264 		return retVal;
265     }
266 
267     /**
268      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-4).
269      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
270      * it will return zero.
271      */
272     public int getOm14_PermittedDataTypesReps() {
273     	return this.getReps(4);
274     }
275 
276 
277     /**
278      * Inserts a repetition of
279      * OM1-4: "Permitted Data Types" at a specific index
280      *
281      * @param rep The repetition index (0-indexed)
282      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
283      */
284     public ID insertPermittedDataTypes(int rep) throws HL7Exception { 
285         return (ID) super.insertRepetition(4, rep);
286     }
287 
288 
289     /**
290      * Inserts a repetition of
291      * OM1-4: "Permitted Data Types" at a specific index
292      *
293      * @param rep The repetition index (0-indexed)
294      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
295      */
296     public ID insertOm14_PermittedDataTypes(int rep) throws HL7Exception { 
297         return (ID) super.insertRepetition(4, rep);
298     }
299 
300 
301     /**
302      * Removes a repetition of
303      * OM1-4: "Permitted Data Types" at a specific index
304      *
305      * @param rep The repetition index (0-indexed)
306      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
307      */
308     public ID removePermittedDataTypes(int rep) throws HL7Exception { 
309         return (ID) super.removeRepetition(4, rep);
310     }
311 
312 
313     /**
314      * Removes a repetition of
315      * OM1-4: "Permitted Data Types" at a specific index
316      *
317      * @param rep The repetition index (0-indexed)
318      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
319      */
320     public ID removeOm14_PermittedDataTypes(int rep) throws HL7Exception { 
321         return (ID) super.removeRepetition(4, rep);
322     }
323 
324 
325 
326 
327     /**
328      * Returns
329      * OM1-5: "Specimen Required" - creates it if necessary
330      */
331     public ID getSpecimenRequired() { 
332 		ID retVal = this.getTypedField(5, 0);
333 		return retVal;
334     }
335     
336     /**
337      * Returns
338      * OM1-5: "Specimen Required" - creates it if necessary
339      */
340     public ID getOm15_SpecimenRequired() { 
341 		ID retVal = this.getTypedField(5, 0);
342 		return retVal;
343     }
344 
345 
346 
347     /**
348      * Returns
349      * OM1-6: "Producer ID" - creates it if necessary
350      */
351     public CE getProducerID() { 
352 		CE retVal = this.getTypedField(6, 0);
353 		return retVal;
354     }
355     
356     /**
357      * Returns
358      * OM1-6: "Producer ID" - creates it if necessary
359      */
360     public CE getOm16_ProducerID() { 
361 		CE retVal = this.getTypedField(6, 0);
362 		return retVal;
363     }
364 
365 
366 
367     /**
368      * Returns
369      * OM1-7: "Observation Description" - creates it if necessary
370      */
371     public TX getObservationDescription() { 
372 		TX retVal = this.getTypedField(7, 0);
373 		return retVal;
374     }
375     
376     /**
377      * Returns
378      * OM1-7: "Observation Description" - creates it if necessary
379      */
380     public TX getOm17_ObservationDescription() { 
381 		TX retVal = this.getTypedField(7, 0);
382 		return retVal;
383     }
384 
385 
386 
387     /**
388      * Returns
389      * OM1-8: "Other test / observation IDs for the observation" - creates it if necessary
390      */
391     public CE getOtherTestObservationIDsForTheObservation() { 
392 		CE retVal = this.getTypedField(8, 0);
393 		return retVal;
394     }
395     
396     /**
397      * Returns
398      * OM1-8: "Other test / observation IDs for the observation" - creates it if necessary
399      */
400     public CE getOm18_OtherTestObservationIDsForTheObservation() { 
401 		CE retVal = this.getTypedField(8, 0);
402 		return retVal;
403     }
404 
405 
406     /**
407      * Returns all repetitions of Other Names (OM1-9).
408      */
409     public ST[] getOtherNames() {
410     	ST[] retVal = this.getTypedField(9, new ST[0]);
411     	return retVal;
412     }
413 
414 
415     /**
416      * Returns all repetitions of Other Names (OM1-9).
417      */
418     public ST[] getOm19_OtherNames() {
419     	ST[] retVal = this.getTypedField(9, new ST[0]);
420     	return retVal;
421     }
422 
423 
424     /**
425      * Returns a count of the current number of repetitions of Other Names (OM1-9).
426      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
427      * it will return zero.
428      */
429     public int getOtherNamesReps() {
430     	return this.getReps(9);
431     }
432 
433 
434     /**
435      * Returns a specific repetition of
436      * OM1-9: "Other Names" - creates it if necessary
437      *
438      * @param rep The repetition index (0-indexed)
439      */
440     public ST getOtherNames(int rep) { 
441 		ST retVal = this.getTypedField(9, rep);
442 		return retVal;
443     }
444 
445     /**
446      * Returns a specific repetition of
447      * OM1-9: "Other Names" - creates it if necessary
448      *
449      * @param rep The repetition index (0-indexed)
450      */
451     public ST getOm19_OtherNames(int rep) { 
452 		ST retVal = this.getTypedField(9, rep);
453 		return retVal;
454     }
455 
456     /**
457      * Returns a count of the current number of repetitions of Other Names (OM1-9).
458      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
459      * it will return zero.
460      */
461     public int getOm19_OtherNamesReps() {
462     	return this.getReps(9);
463     }
464 
465 
466     /**
467      * Inserts a repetition of
468      * OM1-9: "Other Names" at a specific index
469      *
470      * @param rep The repetition index (0-indexed)
471      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
472      */
473     public ST insertOtherNames(int rep) throws HL7Exception { 
474         return (ST) super.insertRepetition(9, rep);
475     }
476 
477 
478     /**
479      * Inserts a repetition of
480      * OM1-9: "Other Names" at a specific index
481      *
482      * @param rep The repetition index (0-indexed)
483      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
484      */
485     public ST insertOm19_OtherNames(int rep) throws HL7Exception { 
486         return (ST) super.insertRepetition(9, rep);
487     }
488 
489 
490     /**
491      * Removes a repetition of
492      * OM1-9: "Other Names" at a specific index
493      *
494      * @param rep The repetition index (0-indexed)
495      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
496      */
497     public ST removeOtherNames(int rep) throws HL7Exception { 
498         return (ST) super.removeRepetition(9, rep);
499     }
500 
501 
502     /**
503      * Removes a repetition of
504      * OM1-9: "Other Names" at a specific index
505      *
506      * @param rep The repetition index (0-indexed)
507      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
508      */
509     public ST removeOm19_OtherNames(int rep) throws HL7Exception { 
510         return (ST) super.removeRepetition(9, rep);
511     }
512 
513 
514 
515 
516     /**
517      * Returns
518      * OM1-10: "Preferred Report Name for the Observation" - creates it if necessary
519      */
520     public ST getPreferredReportNameForTheObservation() { 
521 		ST retVal = this.getTypedField(10, 0);
522 		return retVal;
523     }
524     
525     /**
526      * Returns
527      * OM1-10: "Preferred Report Name for the Observation" - creates it if necessary
528      */
529     public ST getOm110_PreferredReportNameForTheObservation() { 
530 		ST retVal = this.getTypedField(10, 0);
531 		return retVal;
532     }
533 
534 
535 
536     /**
537      * Returns
538      * OM1-11: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary
539      */
540     public ST getPreferredShortNameOrMnemonicForObservation() { 
541 		ST retVal = this.getTypedField(11, 0);
542 		return retVal;
543     }
544     
545     /**
546      * Returns
547      * OM1-11: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary
548      */
549     public ST getOm111_PreferredShortNameOrMnemonicForObservation() { 
550 		ST retVal = this.getTypedField(11, 0);
551 		return retVal;
552     }
553 
554 
555 
556     /**
557      * Returns
558      * OM1-12: "Preferred Long Name for the Observation" - creates it if necessary
559      */
560     public ST getPreferredLongNameForTheObservation() { 
561 		ST retVal = this.getTypedField(12, 0);
562 		return retVal;
563     }
564     
565     /**
566      * Returns
567      * OM1-12: "Preferred Long Name for the Observation" - creates it if necessary
568      */
569     public ST getOm112_PreferredLongNameForTheObservation() { 
570 		ST retVal = this.getTypedField(12, 0);
571 		return retVal;
572     }
573 
574 
575 
576     /**
577      * Returns
578      * OM1-13: "Orderability" - creates it if necessary
579      */
580     public ID getOrderability() { 
581 		ID retVal = this.getTypedField(13, 0);
582 		return retVal;
583     }
584     
585     /**
586      * Returns
587      * OM1-13: "Orderability" - creates it if necessary
588      */
589     public ID getOm113_Orderability() { 
590 		ID retVal = this.getTypedField(13, 0);
591 		return retVal;
592     }
593 
594 
595     /**
596      * Returns all repetitions of Identity of instrument used to perform this study (OM1-14).
597      */
598     public CE[] getIdentityOfInstrumentUsedToPerformThisStudy() {
599     	CE[] retVal = this.getTypedField(14, new CE[0]);
600     	return retVal;
601     }
602 
603 
604     /**
605      * Returns all repetitions of Identity of instrument used to perform this study (OM1-14).
606      */
607     public CE[] getOm114_IdentityOfInstrumentUsedToPerformThisStudy() {
608     	CE[] retVal = this.getTypedField(14, new CE[0]);
609     	return retVal;
610     }
611 
612 
613     /**
614      * Returns a count of the current number of repetitions of Identity of instrument used to perform this study (OM1-14).
615      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
616      * it will return zero.
617      */
618     public int getIdentityOfInstrumentUsedToPerformThisStudyReps() {
619     	return this.getReps(14);
620     }
621 
622 
623     /**
624      * Returns a specific repetition of
625      * OM1-14: "Identity of instrument used to perform this study" - creates it if necessary
626      *
627      * @param rep The repetition index (0-indexed)
628      */
629     public CE getIdentityOfInstrumentUsedToPerformThisStudy(int rep) { 
630 		CE retVal = this.getTypedField(14, rep);
631 		return retVal;
632     }
633 
634     /**
635      * Returns a specific repetition of
636      * OM1-14: "Identity of instrument used to perform this study" - creates it if necessary
637      *
638      * @param rep The repetition index (0-indexed)
639      */
640     public CE getOm114_IdentityOfInstrumentUsedToPerformThisStudy(int rep) { 
641 		CE retVal = this.getTypedField(14, rep);
642 		return retVal;
643     }
644 
645     /**
646      * Returns a count of the current number of repetitions of Identity of instrument used to perform this study (OM1-14).
647      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
648      * it will return zero.
649      */
650     public int getOm114_IdentityOfInstrumentUsedToPerformThisStudyReps() {
651     	return this.getReps(14);
652     }
653 
654 
655     /**
656      * Inserts a repetition of
657      * OM1-14: "Identity of instrument used to perform this study" at a specific index
658      *
659      * @param rep The repetition index (0-indexed)
660      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
661      */
662     public CE insertIdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
663         return (CE) super.insertRepetition(14, rep);
664     }
665 
666 
667     /**
668      * Inserts a repetition of
669      * OM1-14: "Identity of instrument used to perform this study" at a specific index
670      *
671      * @param rep The repetition index (0-indexed)
672      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
673      */
674     public CE insertOm114_IdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
675         return (CE) super.insertRepetition(14, rep);
676     }
677 
678 
679     /**
680      * Removes a repetition of
681      * OM1-14: "Identity of instrument used to perform this study" at a specific index
682      *
683      * @param rep The repetition index (0-indexed)
684      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
685      */
686     public CE removeIdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
687         return (CE) super.removeRepetition(14, rep);
688     }
689 
690 
691     /**
692      * Removes a repetition of
693      * OM1-14: "Identity of instrument used to perform this study" at a specific index
694      *
695      * @param rep The repetition index (0-indexed)
696      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
697      */
698     public CE removeOm114_IdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
699         return (CE) super.removeRepetition(14, rep);
700     }
701 
702 
703 
704     /**
705      * Returns all repetitions of Coded Representation of Method (OM1-15).
706      */
707     public CE[] getCodedRepresentationOfMethod() {
708     	CE[] retVal = this.getTypedField(15, new CE[0]);
709     	return retVal;
710     }
711 
712 
713     /**
714      * Returns all repetitions of Coded Representation of Method (OM1-15).
715      */
716     public CE[] getOm115_CodedRepresentationOfMethod() {
717     	CE[] retVal = this.getTypedField(15, new CE[0]);
718     	return retVal;
719     }
720 
721 
722     /**
723      * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-15).
724      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
725      * it will return zero.
726      */
727     public int getCodedRepresentationOfMethodReps() {
728     	return this.getReps(15);
729     }
730 
731 
732     /**
733      * Returns a specific repetition of
734      * OM1-15: "Coded Representation of Method" - creates it if necessary
735      *
736      * @param rep The repetition index (0-indexed)
737      */
738     public CE getCodedRepresentationOfMethod(int rep) { 
739 		CE retVal = this.getTypedField(15, rep);
740 		return retVal;
741     }
742 
743     /**
744      * Returns a specific repetition of
745      * OM1-15: "Coded Representation of Method" - creates it if necessary
746      *
747      * @param rep The repetition index (0-indexed)
748      */
749     public CE getOm115_CodedRepresentationOfMethod(int rep) { 
750 		CE retVal = this.getTypedField(15, rep);
751 		return retVal;
752     }
753 
754     /**
755      * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-15).
756      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
757      * it will return zero.
758      */
759     public int getOm115_CodedRepresentationOfMethodReps() {
760     	return this.getReps(15);
761     }
762 
763 
764     /**
765      * Inserts a repetition of
766      * OM1-15: "Coded Representation of Method" at a specific index
767      *
768      * @param rep The repetition index (0-indexed)
769      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
770      */
771     public CE insertCodedRepresentationOfMethod(int rep) throws HL7Exception { 
772         return (CE) super.insertRepetition(15, rep);
773     }
774 
775 
776     /**
777      * Inserts a repetition of
778      * OM1-15: "Coded Representation of Method" at a specific index
779      *
780      * @param rep The repetition index (0-indexed)
781      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
782      */
783     public CE insertOm115_CodedRepresentationOfMethod(int rep) throws HL7Exception { 
784         return (CE) super.insertRepetition(15, rep);
785     }
786 
787 
788     /**
789      * Removes a repetition of
790      * OM1-15: "Coded Representation of Method" at a specific index
791      *
792      * @param rep The repetition index (0-indexed)
793      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
794      */
795     public CE removeCodedRepresentationOfMethod(int rep) throws HL7Exception { 
796         return (CE) super.removeRepetition(15, rep);
797     }
798 
799 
800     /**
801      * Removes a repetition of
802      * OM1-15: "Coded Representation of Method" at a specific index
803      *
804      * @param rep The repetition index (0-indexed)
805      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
806      */
807     public CE removeOm115_CodedRepresentationOfMethod(int rep) throws HL7Exception { 
808         return (CE) super.removeRepetition(15, rep);
809     }
810 
811 
812 
813 
814     /**
815      * Returns
816      * OM1-16: "Portable" - creates it if necessary
817      */
818     public ID getPortable() { 
819 		ID retVal = this.getTypedField(16, 0);
820 		return retVal;
821     }
822     
823     /**
824      * Returns
825      * OM1-16: "Portable" - creates it if necessary
826      */
827     public ID getOm116_Portable() { 
828 		ID retVal = this.getTypedField(16, 0);
829 		return retVal;
830     }
831 
832 
833     /**
834      * Returns all repetitions of Observation producing department / section (OM1-17).
835      */
836     public ID[] getObservationProducingDepartmentSection() {
837     	ID[] retVal = this.getTypedField(17, new ID[0]);
838     	return retVal;
839     }
840 
841 
842     /**
843      * Returns all repetitions of Observation producing department / section (OM1-17).
844      */
845     public ID[] getOm117_ObservationProducingDepartmentSection() {
846     	ID[] retVal = this.getTypedField(17, new ID[0]);
847     	return retVal;
848     }
849 
850 
851     /**
852      * Returns a count of the current number of repetitions of Observation producing department / section (OM1-17).
853      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
854      * it will return zero.
855      */
856     public int getObservationProducingDepartmentSectionReps() {
857     	return this.getReps(17);
858     }
859 
860 
861     /**
862      * Returns a specific repetition of
863      * OM1-17: "Observation producing department / section" - creates it if necessary
864      *
865      * @param rep The repetition index (0-indexed)
866      */
867     public ID getObservationProducingDepartmentSection(int rep) { 
868 		ID retVal = this.getTypedField(17, rep);
869 		return retVal;
870     }
871 
872     /**
873      * Returns a specific repetition of
874      * OM1-17: "Observation producing department / section" - creates it if necessary
875      *
876      * @param rep The repetition index (0-indexed)
877      */
878     public ID getOm117_ObservationProducingDepartmentSection(int rep) { 
879 		ID retVal = this.getTypedField(17, rep);
880 		return retVal;
881     }
882 
883     /**
884      * Returns a count of the current number of repetitions of Observation producing department / section (OM1-17).
885      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
886      * it will return zero.
887      */
888     public int getOm117_ObservationProducingDepartmentSectionReps() {
889     	return this.getReps(17);
890     }
891 
892 
893     /**
894      * Inserts a repetition of
895      * OM1-17: "Observation producing department / section" at a specific index
896      *
897      * @param rep The repetition index (0-indexed)
898      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
899      */
900     public ID insertObservationProducingDepartmentSection(int rep) throws HL7Exception { 
901         return (ID) super.insertRepetition(17, rep);
902     }
903 
904 
905     /**
906      * Inserts a repetition of
907      * OM1-17: "Observation producing department / section" at a specific index
908      *
909      * @param rep The repetition index (0-indexed)
910      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
911      */
912     public ID insertOm117_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
913         return (ID) super.insertRepetition(17, rep);
914     }
915 
916 
917     /**
918      * Removes a repetition of
919      * OM1-17: "Observation producing department / section" at a specific index
920      *
921      * @param rep The repetition index (0-indexed)
922      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
923      */
924     public ID removeObservationProducingDepartmentSection(int rep) throws HL7Exception { 
925         return (ID) super.removeRepetition(17, rep);
926     }
927 
928 
929     /**
930      * Removes a repetition of
931      * OM1-17: "Observation producing department / section" at a specific index
932      *
933      * @param rep The repetition index (0-indexed)
934      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
935      */
936     public ID removeOm117_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
937         return (ID) super.removeRepetition(17, rep);
938     }
939 
940 
941 
942 
943     /**
944      * Returns
945      * OM1-18: "Telephone Number of Section" - creates it if necessary
946      */
947     public TN getTelephoneNumberOfSection() { 
948 		TN retVal = this.getTypedField(18, 0);
949 		return retVal;
950     }
951     
952     /**
953      * Returns
954      * OM1-18: "Telephone Number of Section" - creates it if necessary
955      */
956     public TN getOm118_TelephoneNumberOfSection() { 
957 		TN retVal = this.getTypedField(18, 0);
958 		return retVal;
959     }
960 
961 
962 
963     /**
964      * Returns
965      * OM1-19: "Nature of test / observation" - creates it if necessary
966      */
967     public ID getNatureOfTestObservation() { 
968 		ID retVal = this.getTypedField(19, 0);
969 		return retVal;
970     }
971     
972     /**
973      * Returns
974      * OM1-19: "Nature of test / observation" - creates it if necessary
975      */
976     public ID getOm119_NatureOfTestObservation() { 
977 		ID retVal = this.getTypedField(19, 0);
978 		return retVal;
979     }
980 
981 
982 
983     /**
984      * Returns
985      * OM1-20: "Report Subheader" - creates it if necessary
986      */
987     public CE getReportSubheader() { 
988 		CE retVal = this.getTypedField(20, 0);
989 		return retVal;
990     }
991     
992     /**
993      * Returns
994      * OM1-20: "Report Subheader" - creates it if necessary
995      */
996     public CE getOm120_ReportSubheader() { 
997 		CE retVal = this.getTypedField(20, 0);
998 		return retVal;
999     }
1000 
1001 
1002 
1003     /**
1004      * Returns
1005      * OM1-21: "Report Display Order" - creates it if necessary
1006      */
1007     public ST getReportDisplayOrder() { 
1008 		ST retVal = this.getTypedField(21, 0);
1009 		return retVal;
1010     }
1011     
1012     /**
1013      * Returns
1014      * OM1-21: "Report Display Order" - creates it if necessary
1015      */
1016     public ST getOm121_ReportDisplayOrder() { 
1017 		ST retVal = this.getTypedField(21, 0);
1018 		return retVal;
1019     }
1020 
1021 
1022 
1023     /**
1024      * Returns
1025      * OM1-22: "Date / time stamp for any change in definition for obs" - creates it if necessary
1026      */
1027     public TS getDateTimeStampForAnyChangeInDefinitionForObs() { 
1028 		TS retVal = this.getTypedField(22, 0);
1029 		return retVal;
1030     }
1031     
1032     /**
1033      * Returns
1034      * OM1-22: "Date / time stamp for any change in definition for obs" - creates it if necessary
1035      */
1036     public TS getOm122_DateTimeStampForAnyChangeInDefinitionForObs() { 
1037 		TS retVal = this.getTypedField(22, 0);
1038 		return retVal;
1039     }
1040 
1041 
1042 
1043     /**
1044      * Returns
1045      * OM1-23: "Effective date / time of change" - creates it if necessary
1046      */
1047     public TS getEffectiveDateTimeOfChange() { 
1048 		TS retVal = this.getTypedField(23, 0);
1049 		return retVal;
1050     }
1051     
1052     /**
1053      * Returns
1054      * OM1-23: "Effective date / time of change" - creates it if necessary
1055      */
1056     public TS getOm123_EffectiveDateTimeOfChange() { 
1057 		TS retVal = this.getTypedField(23, 0);
1058 		return retVal;
1059     }
1060 
1061 
1062 
1063     /**
1064      * Returns
1065      * OM1-24: "Typical Turn-around Time" - creates it if necessary
1066      */
1067     public NM getTypicalTurnAroundTime() { 
1068 		NM retVal = this.getTypedField(24, 0);
1069 		return retVal;
1070     }
1071     
1072     /**
1073      * Returns
1074      * OM1-24: "Typical Turn-around Time" - creates it if necessary
1075      */
1076     public NM getOm124_TypicalTurnAroundTime() { 
1077 		NM retVal = this.getTypedField(24, 0);
1078 		return retVal;
1079     }
1080 
1081 
1082 
1083     /**
1084      * Returns
1085      * OM1-25: "Processing Time" - creates it if necessary
1086      */
1087     public NM getProcessingTime() { 
1088 		NM retVal = this.getTypedField(25, 0);
1089 		return retVal;
1090     }
1091     
1092     /**
1093      * Returns
1094      * OM1-25: "Processing Time" - creates it if necessary
1095      */
1096     public NM getOm125_ProcessingTime() { 
1097 		NM retVal = this.getTypedField(25, 0);
1098 		return retVal;
1099     }
1100 
1101 
1102     /**
1103      * Returns all repetitions of Processing Priority (OM1-26).
1104      */
1105     public ID[] getProcessingPriority() {
1106     	ID[] retVal = this.getTypedField(26, new ID[0]);
1107     	return retVal;
1108     }
1109 
1110 
1111     /**
1112      * Returns all repetitions of Processing Priority (OM1-26).
1113      */
1114     public ID[] getOm126_ProcessingPriority() {
1115     	ID[] retVal = this.getTypedField(26, new ID[0]);
1116     	return retVal;
1117     }
1118 
1119 
1120     /**
1121      * Returns a count of the current number of repetitions of Processing Priority (OM1-26).
1122      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1123      * it will return zero.
1124      */
1125     public int getProcessingPriorityReps() {
1126     	return this.getReps(26);
1127     }
1128 
1129 
1130     /**
1131      * Returns a specific repetition of
1132      * OM1-26: "Processing Priority" - creates it if necessary
1133      *
1134      * @param rep The repetition index (0-indexed)
1135      */
1136     public ID getProcessingPriority(int rep) { 
1137 		ID retVal = this.getTypedField(26, rep);
1138 		return retVal;
1139     }
1140 
1141     /**
1142      * Returns a specific repetition of
1143      * OM1-26: "Processing Priority" - creates it if necessary
1144      *
1145      * @param rep The repetition index (0-indexed)
1146      */
1147     public ID getOm126_ProcessingPriority(int rep) { 
1148 		ID retVal = this.getTypedField(26, rep);
1149 		return retVal;
1150     }
1151 
1152     /**
1153      * Returns a count of the current number of repetitions of Processing Priority (OM1-26).
1154      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1155      * it will return zero.
1156      */
1157     public int getOm126_ProcessingPriorityReps() {
1158     	return this.getReps(26);
1159     }
1160 
1161 
1162     /**
1163      * Inserts a repetition of
1164      * OM1-26: "Processing Priority" at a specific index
1165      *
1166      * @param rep The repetition index (0-indexed)
1167      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1168      */
1169     public ID insertProcessingPriority(int rep) throws HL7Exception { 
1170         return (ID) super.insertRepetition(26, rep);
1171     }
1172 
1173 
1174     /**
1175      * Inserts a repetition of
1176      * OM1-26: "Processing Priority" at a specific index
1177      *
1178      * @param rep The repetition index (0-indexed)
1179      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1180      */
1181     public ID insertOm126_ProcessingPriority(int rep) throws HL7Exception { 
1182         return (ID) super.insertRepetition(26, rep);
1183     }
1184 
1185 
1186     /**
1187      * Removes a repetition of
1188      * OM1-26: "Processing Priority" at a specific index
1189      *
1190      * @param rep The repetition index (0-indexed)
1191      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1192      */
1193     public ID removeProcessingPriority(int rep) throws HL7Exception { 
1194         return (ID) super.removeRepetition(26, rep);
1195     }
1196 
1197 
1198     /**
1199      * Removes a repetition of
1200      * OM1-26: "Processing Priority" at a specific index
1201      *
1202      * @param rep The repetition index (0-indexed)
1203      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1204      */
1205     public ID removeOm126_ProcessingPriority(int rep) throws HL7Exception { 
1206         return (ID) super.removeRepetition(26, rep);
1207     }
1208 
1209 
1210 
1211 
1212     /**
1213      * Returns
1214      * OM1-27: "Reporting Priority" - creates it if necessary
1215      */
1216     public ID getReportingPriority() { 
1217 		ID retVal = this.getTypedField(27, 0);
1218 		return retVal;
1219     }
1220     
1221     /**
1222      * Returns
1223      * OM1-27: "Reporting Priority" - creates it if necessary
1224      */
1225     public ID getOm127_ReportingPriority() { 
1226 		ID retVal = this.getTypedField(27, 0);
1227 		return retVal;
1228     }
1229 
1230 
1231     /**
1232      * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-28).
1233      */
1234     public CE[] getOutsideSiteSWhereObservationMayBePerformed() {
1235     	CE[] retVal = this.getTypedField(28, new CE[0]);
1236     	return retVal;
1237     }
1238 
1239 
1240     /**
1241      * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-28).
1242      */
1243     public CE[] getOm128_OutsideSiteSWhereObservationMayBePerformed() {
1244     	CE[] retVal = this.getTypedField(28, new CE[0]);
1245     	return retVal;
1246     }
1247 
1248 
1249     /**
1250      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-28).
1251      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1252      * it will return zero.
1253      */
1254     public int getOutsideSiteSWhereObservationMayBePerformedReps() {
1255     	return this.getReps(28);
1256     }
1257 
1258 
1259     /**
1260      * Returns a specific repetition of
1261      * OM1-28: "Outside Site(s) Where Observation may be Performed" - creates it if necessary
1262      *
1263      * @param rep The repetition index (0-indexed)
1264      */
1265     public CE getOutsideSiteSWhereObservationMayBePerformed(int rep) { 
1266 		CE retVal = this.getTypedField(28, rep);
1267 		return retVal;
1268     }
1269 
1270     /**
1271      * Returns a specific repetition of
1272      * OM1-28: "Outside Site(s) Where Observation may be Performed" - creates it if necessary
1273      *
1274      * @param rep The repetition index (0-indexed)
1275      */
1276     public CE getOm128_OutsideSiteSWhereObservationMayBePerformed(int rep) { 
1277 		CE retVal = this.getTypedField(28, rep);
1278 		return retVal;
1279     }
1280 
1281     /**
1282      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-28).
1283      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1284      * it will return zero.
1285      */
1286     public int getOm128_OutsideSiteSWhereObservationMayBePerformedReps() {
1287     	return this.getReps(28);
1288     }
1289 
1290 
1291     /**
1292      * Inserts a repetition of
1293      * OM1-28: "Outside Site(s) Where Observation may be Performed" at a specific index
1294      *
1295      * @param rep The repetition index (0-indexed)
1296      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1297      */
1298     public CE insertOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1299         return (CE) super.insertRepetition(28, rep);
1300     }
1301 
1302 
1303     /**
1304      * Inserts a repetition of
1305      * OM1-28: "Outside Site(s) Where Observation may be Performed" at a specific index
1306      *
1307      * @param rep The repetition index (0-indexed)
1308      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1309      */
1310     public CE insertOm128_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1311         return (CE) super.insertRepetition(28, rep);
1312     }
1313 
1314 
1315     /**
1316      * Removes a repetition of
1317      * OM1-28: "Outside Site(s) Where Observation may be Performed" at a specific index
1318      *
1319      * @param rep The repetition index (0-indexed)
1320      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1321      */
1322     public CE removeOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1323         return (CE) super.removeRepetition(28, rep);
1324     }
1325 
1326 
1327     /**
1328      * Removes a repetition of
1329      * OM1-28: "Outside Site(s) Where Observation may be Performed" at a specific index
1330      *
1331      * @param rep The repetition index (0-indexed)
1332      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1333      */
1334     public CE removeOm128_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1335         return (CE) super.removeRepetition(28, rep);
1336     }
1337 
1338 
1339 
1340     /**
1341      * Returns all repetitions of Address of Outside Site(s) (OM1-29).
1342      */
1343     public AD[] getAddressOfOutsideSiteS() {
1344     	AD[] retVal = this.getTypedField(29, new AD[0]);
1345     	return retVal;
1346     }
1347 
1348 
1349     /**
1350      * Returns all repetitions of Address of Outside Site(s) (OM1-29).
1351      */
1352     public AD[] getOm129_AddressOfOutsideSiteS() {
1353     	AD[] retVal = this.getTypedField(29, new AD[0]);
1354     	return retVal;
1355     }
1356 
1357 
1358     /**
1359      * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-29).
1360      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1361      * it will return zero.
1362      */
1363     public int getAddressOfOutsideSiteSReps() {
1364     	return this.getReps(29);
1365     }
1366 
1367 
1368     /**
1369      * Returns a specific repetition of
1370      * OM1-29: "Address of Outside Site(s)" - creates it if necessary
1371      *
1372      * @param rep The repetition index (0-indexed)
1373      */
1374     public AD getAddressOfOutsideSiteS(int rep) { 
1375 		AD retVal = this.getTypedField(29, rep);
1376 		return retVal;
1377     }
1378 
1379     /**
1380      * Returns a specific repetition of
1381      * OM1-29: "Address of Outside Site(s)" - creates it if necessary
1382      *
1383      * @param rep The repetition index (0-indexed)
1384      */
1385     public AD getOm129_AddressOfOutsideSiteS(int rep) { 
1386 		AD retVal = this.getTypedField(29, rep);
1387 		return retVal;
1388     }
1389 
1390     /**
1391      * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-29).
1392      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1393      * it will return zero.
1394      */
1395     public int getOm129_AddressOfOutsideSiteSReps() {
1396     	return this.getReps(29);
1397     }
1398 
1399 
1400     /**
1401      * Inserts a repetition of
1402      * OM1-29: "Address of Outside Site(s)" at a specific index
1403      *
1404      * @param rep The repetition index (0-indexed)
1405      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1406      */
1407     public AD insertAddressOfOutsideSiteS(int rep) throws HL7Exception { 
1408         return (AD) super.insertRepetition(29, rep);
1409     }
1410 
1411 
1412     /**
1413      * Inserts a repetition of
1414      * OM1-29: "Address of Outside Site(s)" at a specific index
1415      *
1416      * @param rep The repetition index (0-indexed)
1417      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1418      */
1419     public AD insertOm129_AddressOfOutsideSiteS(int rep) throws HL7Exception { 
1420         return (AD) super.insertRepetition(29, rep);
1421     }
1422 
1423 
1424     /**
1425      * Removes a repetition of
1426      * OM1-29: "Address of Outside Site(s)" at a specific index
1427      *
1428      * @param rep The repetition index (0-indexed)
1429      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1430      */
1431     public AD removeAddressOfOutsideSiteS(int rep) throws HL7Exception { 
1432         return (AD) super.removeRepetition(29, rep);
1433     }
1434 
1435 
1436     /**
1437      * Removes a repetition of
1438      * OM1-29: "Address of Outside Site(s)" at a specific index
1439      *
1440      * @param rep The repetition index (0-indexed)
1441      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1442      */
1443     public AD removeOm129_AddressOfOutsideSiteS(int rep) throws HL7Exception { 
1444         return (AD) super.removeRepetition(29, rep);
1445     }
1446 
1447 
1448 
1449     /**
1450      * Returns all repetitions of Phone Number of Outside Site (OM1-30).
1451      */
1452     public TN[] getPhoneNumberOfOutsideSite() {
1453     	TN[] retVal = this.getTypedField(30, new TN[0]);
1454     	return retVal;
1455     }
1456 
1457 
1458     /**
1459      * Returns all repetitions of Phone Number of Outside Site (OM1-30).
1460      */
1461     public TN[] getOm130_PhoneNumberOfOutsideSite() {
1462     	TN[] retVal = this.getTypedField(30, new TN[0]);
1463     	return retVal;
1464     }
1465 
1466 
1467     /**
1468      * Returns a count of the current number of repetitions of Phone Number of Outside Site (OM1-30).
1469      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1470      * it will return zero.
1471      */
1472     public int getPhoneNumberOfOutsideSiteReps() {
1473     	return this.getReps(30);
1474     }
1475 
1476 
1477     /**
1478      * Returns a specific repetition of
1479      * OM1-30: "Phone Number of Outside Site" - creates it if necessary
1480      *
1481      * @param rep The repetition index (0-indexed)
1482      */
1483     public TN getPhoneNumberOfOutsideSite(int rep) { 
1484 		TN retVal = this.getTypedField(30, rep);
1485 		return retVal;
1486     }
1487 
1488     /**
1489      * Returns a specific repetition of
1490      * OM1-30: "Phone Number of Outside Site" - creates it if necessary
1491      *
1492      * @param rep The repetition index (0-indexed)
1493      */
1494     public TN getOm130_PhoneNumberOfOutsideSite(int rep) { 
1495 		TN retVal = this.getTypedField(30, rep);
1496 		return retVal;
1497     }
1498 
1499     /**
1500      * Returns a count of the current number of repetitions of Phone Number of Outside Site (OM1-30).
1501      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1502      * it will return zero.
1503      */
1504     public int getOm130_PhoneNumberOfOutsideSiteReps() {
1505     	return this.getReps(30);
1506     }
1507 
1508 
1509     /**
1510      * Inserts a repetition of
1511      * OM1-30: "Phone Number of Outside Site" at a specific index
1512      *
1513      * @param rep The repetition index (0-indexed)
1514      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1515      */
1516     public TN insertPhoneNumberOfOutsideSite(int rep) throws HL7Exception { 
1517         return (TN) super.insertRepetition(30, rep);
1518     }
1519 
1520 
1521     /**
1522      * Inserts a repetition of
1523      * OM1-30: "Phone Number of Outside Site" at a specific index
1524      *
1525      * @param rep The repetition index (0-indexed)
1526      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1527      */
1528     public TN insertOm130_PhoneNumberOfOutsideSite(int rep) throws HL7Exception { 
1529         return (TN) super.insertRepetition(30, rep);
1530     }
1531 
1532 
1533     /**
1534      * Removes a repetition of
1535      * OM1-30: "Phone Number of Outside Site" at a specific index
1536      *
1537      * @param rep The repetition index (0-indexed)
1538      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1539      */
1540     public TN removePhoneNumberOfOutsideSite(int rep) throws HL7Exception { 
1541         return (TN) super.removeRepetition(30, rep);
1542     }
1543 
1544 
1545     /**
1546      * Removes a repetition of
1547      * OM1-30: "Phone Number of Outside Site" at a specific index
1548      *
1549      * @param rep The repetition index (0-indexed)
1550      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1551      */
1552     public TN removeOm130_PhoneNumberOfOutsideSite(int rep) throws HL7Exception { 
1553         return (TN) super.removeRepetition(30, rep);
1554     }
1555 
1556 
1557 
1558 
1559     /**
1560      * Returns
1561      * OM1-31: "Confidentiality Code" - creates it if necessary
1562      */
1563     public ID getConfidentialityCode() { 
1564 		ID retVal = this.getTypedField(31, 0);
1565 		return retVal;
1566     }
1567     
1568     /**
1569      * Returns
1570      * OM1-31: "Confidentiality Code" - creates it if necessary
1571      */
1572     public ID getOm131_ConfidentialityCode() { 
1573 		ID retVal = this.getTypedField(31, 0);
1574 		return retVal;
1575     }
1576 
1577 
1578     /**
1579      * Returns all repetitions of Observations required to interpret the observation (OM1-32).
1580      */
1581     public CE[] getObservationsRequiredToInterpretTheObservation() {
1582     	CE[] retVal = this.getTypedField(32, new CE[0]);
1583     	return retVal;
1584     }
1585 
1586 
1587     /**
1588      * Returns all repetitions of Observations required to interpret the observation (OM1-32).
1589      */
1590     public CE[] getOm132_ObservationsRequiredToInterpretTheObservation() {
1591     	CE[] retVal = this.getTypedField(32, new CE[0]);
1592     	return retVal;
1593     }
1594 
1595 
1596     /**
1597      * Returns a count of the current number of repetitions of Observations required to interpret the observation (OM1-32).
1598      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1599      * it will return zero.
1600      */
1601     public int getObservationsRequiredToInterpretTheObservationReps() {
1602     	return this.getReps(32);
1603     }
1604 
1605 
1606     /**
1607      * Returns a specific repetition of
1608      * OM1-32: "Observations required to interpret the observation" - creates it if necessary
1609      *
1610      * @param rep The repetition index (0-indexed)
1611      */
1612     public CE getObservationsRequiredToInterpretTheObservation(int rep) { 
1613 		CE retVal = this.getTypedField(32, rep);
1614 		return retVal;
1615     }
1616 
1617     /**
1618      * Returns a specific repetition of
1619      * OM1-32: "Observations required to interpret the observation" - creates it if necessary
1620      *
1621      * @param rep The repetition index (0-indexed)
1622      */
1623     public CE getOm132_ObservationsRequiredToInterpretTheObservation(int rep) { 
1624 		CE retVal = this.getTypedField(32, rep);
1625 		return retVal;
1626     }
1627 
1628     /**
1629      * Returns a count of the current number of repetitions of Observations required to interpret the observation (OM1-32).
1630      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1631      * it will return zero.
1632      */
1633     public int getOm132_ObservationsRequiredToInterpretTheObservationReps() {
1634     	return this.getReps(32);
1635     }
1636 
1637 
1638     /**
1639      * Inserts a repetition of
1640      * OM1-32: "Observations required to interpret the observation" at a specific index
1641      *
1642      * @param rep The repetition index (0-indexed)
1643      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1644      */
1645     public CE insertObservationsRequiredToInterpretTheObservation(int rep) throws HL7Exception { 
1646         return (CE) super.insertRepetition(32, rep);
1647     }
1648 
1649 
1650     /**
1651      * Inserts a repetition of
1652      * OM1-32: "Observations required to interpret the observation" at a specific index
1653      *
1654      * @param rep The repetition index (0-indexed)
1655      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1656      */
1657     public CE insertOm132_ObservationsRequiredToInterpretTheObservation(int rep) throws HL7Exception { 
1658         return (CE) super.insertRepetition(32, rep);
1659     }
1660 
1661 
1662     /**
1663      * Removes a repetition of
1664      * OM1-32: "Observations required to interpret the observation" at a specific index
1665      *
1666      * @param rep The repetition index (0-indexed)
1667      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1668      */
1669     public CE removeObservationsRequiredToInterpretTheObservation(int rep) throws HL7Exception { 
1670         return (CE) super.removeRepetition(32, rep);
1671     }
1672 
1673 
1674     /**
1675      * Removes a repetition of
1676      * OM1-32: "Observations required to interpret the observation" at a specific index
1677      *
1678      * @param rep The repetition index (0-indexed)
1679      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1680      */
1681     public CE removeOm132_ObservationsRequiredToInterpretTheObservation(int rep) throws HL7Exception { 
1682         return (CE) super.removeRepetition(32, rep);
1683     }
1684 
1685 
1686 
1687 
1688     /**
1689      * Returns
1690      * OM1-33: "Interpretation of Observations" - creates it if necessary
1691      */
1692     public TX getInterpretationOfObservations() { 
1693 		TX retVal = this.getTypedField(33, 0);
1694 		return retVal;
1695     }
1696     
1697     /**
1698      * Returns
1699      * OM1-33: "Interpretation of Observations" - creates it if necessary
1700      */
1701     public TX getOm133_InterpretationOfObservations() { 
1702 		TX retVal = this.getTypedField(33, 0);
1703 		return retVal;
1704     }
1705 
1706 
1707     /**
1708      * Returns all repetitions of Contraindications to Observations (OM1-34).
1709      */
1710     public CE[] getContraindicationsToObservations() {
1711     	CE[] retVal = this.getTypedField(34, new CE[0]);
1712     	return retVal;
1713     }
1714 
1715 
1716     /**
1717      * Returns all repetitions of Contraindications to Observations (OM1-34).
1718      */
1719     public CE[] getOm134_ContraindicationsToObservations() {
1720     	CE[] retVal = this.getTypedField(34, new CE[0]);
1721     	return retVal;
1722     }
1723 
1724 
1725     /**
1726      * Returns a count of the current number of repetitions of Contraindications to Observations (OM1-34).
1727      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1728      * it will return zero.
1729      */
1730     public int getContraindicationsToObservationsReps() {
1731     	return this.getReps(34);
1732     }
1733 
1734 
1735     /**
1736      * Returns a specific repetition of
1737      * OM1-34: "Contraindications to Observations" - creates it if necessary
1738      *
1739      * @param rep The repetition index (0-indexed)
1740      */
1741     public CE getContraindicationsToObservations(int rep) { 
1742 		CE retVal = this.getTypedField(34, rep);
1743 		return retVal;
1744     }
1745 
1746     /**
1747      * Returns a specific repetition of
1748      * OM1-34: "Contraindications to Observations" - creates it if necessary
1749      *
1750      * @param rep The repetition index (0-indexed)
1751      */
1752     public CE getOm134_ContraindicationsToObservations(int rep) { 
1753 		CE retVal = this.getTypedField(34, rep);
1754 		return retVal;
1755     }
1756 
1757     /**
1758      * Returns a count of the current number of repetitions of Contraindications to Observations (OM1-34).
1759      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1760      * it will return zero.
1761      */
1762     public int getOm134_ContraindicationsToObservationsReps() {
1763     	return this.getReps(34);
1764     }
1765 
1766 
1767     /**
1768      * Inserts a repetition of
1769      * OM1-34: "Contraindications to Observations" at a specific index
1770      *
1771      * @param rep The repetition index (0-indexed)
1772      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1773      */
1774     public CE insertContraindicationsToObservations(int rep) throws HL7Exception { 
1775         return (CE) super.insertRepetition(34, rep);
1776     }
1777 
1778 
1779     /**
1780      * Inserts a repetition of
1781      * OM1-34: "Contraindications to Observations" at a specific index
1782      *
1783      * @param rep The repetition index (0-indexed)
1784      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1785      */
1786     public CE insertOm134_ContraindicationsToObservations(int rep) throws HL7Exception { 
1787         return (CE) super.insertRepetition(34, rep);
1788     }
1789 
1790 
1791     /**
1792      * Removes a repetition of
1793      * OM1-34: "Contraindications to Observations" at a specific index
1794      *
1795      * @param rep The repetition index (0-indexed)
1796      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1797      */
1798     public CE removeContraindicationsToObservations(int rep) throws HL7Exception { 
1799         return (CE) super.removeRepetition(34, rep);
1800     }
1801 
1802 
1803     /**
1804      * Removes a repetition of
1805      * OM1-34: "Contraindications to Observations" at a specific index
1806      *
1807      * @param rep The repetition index (0-indexed)
1808      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1809      */
1810     public CE removeOm134_ContraindicationsToObservations(int rep) throws HL7Exception { 
1811         return (CE) super.removeRepetition(34, rep);
1812     }
1813 
1814 
1815 
1816     /**
1817      * Returns all repetitions of Reflex tests / observations (OM1-35).
1818      */
1819     public CE[] getReflexTestsObservations() {
1820     	CE[] retVal = this.getTypedField(35, new CE[0]);
1821     	return retVal;
1822     }
1823 
1824 
1825     /**
1826      * Returns all repetitions of Reflex tests / observations (OM1-35).
1827      */
1828     public CE[] getOm135_ReflexTestsObservations() {
1829     	CE[] retVal = this.getTypedField(35, new CE[0]);
1830     	return retVal;
1831     }
1832 
1833 
1834     /**
1835      * Returns a count of the current number of repetitions of Reflex tests / observations (OM1-35).
1836      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1837      * it will return zero.
1838      */
1839     public int getReflexTestsObservationsReps() {
1840     	return this.getReps(35);
1841     }
1842 
1843 
1844     /**
1845      * Returns a specific repetition of
1846      * OM1-35: "Reflex tests / observations" - creates it if necessary
1847      *
1848      * @param rep The repetition index (0-indexed)
1849      */
1850     public CE getReflexTestsObservations(int rep) { 
1851 		CE retVal = this.getTypedField(35, rep);
1852 		return retVal;
1853     }
1854 
1855     /**
1856      * Returns a specific repetition of
1857      * OM1-35: "Reflex tests / observations" - creates it if necessary
1858      *
1859      * @param rep The repetition index (0-indexed)
1860      */
1861     public CE getOm135_ReflexTestsObservations(int rep) { 
1862 		CE retVal = this.getTypedField(35, rep);
1863 		return retVal;
1864     }
1865 
1866     /**
1867      * Returns a count of the current number of repetitions of Reflex tests / observations (OM1-35).
1868      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1869      * it will return zero.
1870      */
1871     public int getOm135_ReflexTestsObservationsReps() {
1872     	return this.getReps(35);
1873     }
1874 
1875 
1876     /**
1877      * Inserts a repetition of
1878      * OM1-35: "Reflex tests / observations" at a specific index
1879      *
1880      * @param rep The repetition index (0-indexed)
1881      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1882      */
1883     public CE insertReflexTestsObservations(int rep) throws HL7Exception { 
1884         return (CE) super.insertRepetition(35, rep);
1885     }
1886 
1887 
1888     /**
1889      * Inserts a repetition of
1890      * OM1-35: "Reflex tests / observations" at a specific index
1891      *
1892      * @param rep The repetition index (0-indexed)
1893      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1894      */
1895     public CE insertOm135_ReflexTestsObservations(int rep) throws HL7Exception { 
1896         return (CE) super.insertRepetition(35, rep);
1897     }
1898 
1899 
1900     /**
1901      * Removes a repetition of
1902      * OM1-35: "Reflex tests / observations" at a specific index
1903      *
1904      * @param rep The repetition index (0-indexed)
1905      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1906      */
1907     public CE removeReflexTestsObservations(int rep) throws HL7Exception { 
1908         return (CE) super.removeRepetition(35, rep);
1909     }
1910 
1911 
1912     /**
1913      * Removes a repetition of
1914      * OM1-35: "Reflex tests / observations" at a specific index
1915      *
1916      * @param rep The repetition index (0-indexed)
1917      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1918      */
1919     public CE removeOm135_ReflexTestsObservations(int rep) throws HL7Exception { 
1920         return (CE) super.removeRepetition(35, rep);
1921     }
1922 
1923 
1924 
1925 
1926     /**
1927      * Returns
1928      * OM1-36: "Rules that Trigger Reflex Testing" - creates it if necessary
1929      */
1930     public ST getRulesThatTriggerReflexTesting() { 
1931 		ST retVal = this.getTypedField(36, 0);
1932 		return retVal;
1933     }
1934     
1935     /**
1936      * Returns
1937      * OM1-36: "Rules that Trigger Reflex Testing" - creates it if necessary
1938      */
1939     public ST getOm136_RulesThatTriggerReflexTesting() { 
1940 		ST retVal = this.getTypedField(36, 0);
1941 		return retVal;
1942     }
1943 
1944 
1945     /**
1946      * Returns all repetitions of Fixed Canned Message (OM1-37).
1947      */
1948     public CE[] getFixedCannedMessage() {
1949     	CE[] retVal = this.getTypedField(37, new CE[0]);
1950     	return retVal;
1951     }
1952 
1953 
1954     /**
1955      * Returns all repetitions of Fixed Canned Message (OM1-37).
1956      */
1957     public CE[] getOm137_FixedCannedMessage() {
1958     	CE[] retVal = this.getTypedField(37, new CE[0]);
1959     	return retVal;
1960     }
1961 
1962 
1963     /**
1964      * Returns a count of the current number of repetitions of Fixed Canned Message (OM1-37).
1965      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1966      * it will return zero.
1967      */
1968     public int getFixedCannedMessageReps() {
1969     	return this.getReps(37);
1970     }
1971 
1972 
1973     /**
1974      * Returns a specific repetition of
1975      * OM1-37: "Fixed Canned Message" - creates it if necessary
1976      *
1977      * @param rep The repetition index (0-indexed)
1978      */
1979     public CE getFixedCannedMessage(int rep) { 
1980 		CE retVal = this.getTypedField(37, rep);
1981 		return retVal;
1982     }
1983 
1984     /**
1985      * Returns a specific repetition of
1986      * OM1-37: "Fixed Canned Message" - creates it if necessary
1987      *
1988      * @param rep The repetition index (0-indexed)
1989      */
1990     public CE getOm137_FixedCannedMessage(int rep) { 
1991 		CE retVal = this.getTypedField(37, rep);
1992 		return retVal;
1993     }
1994 
1995     /**
1996      * Returns a count of the current number of repetitions of Fixed Canned Message (OM1-37).
1997      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1998      * it will return zero.
1999      */
2000     public int getOm137_FixedCannedMessageReps() {
2001     	return this.getReps(37);
2002     }
2003 
2004 
2005     /**
2006      * Inserts a repetition of
2007      * OM1-37: "Fixed Canned Message" at a specific index
2008      *
2009      * @param rep The repetition index (0-indexed)
2010      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2011      */
2012     public CE insertFixedCannedMessage(int rep) throws HL7Exception { 
2013         return (CE) super.insertRepetition(37, rep);
2014     }
2015 
2016 
2017     /**
2018      * Inserts a repetition of
2019      * OM1-37: "Fixed Canned Message" at a specific index
2020      *
2021      * @param rep The repetition index (0-indexed)
2022      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2023      */
2024     public CE insertOm137_FixedCannedMessage(int rep) throws HL7Exception { 
2025         return (CE) super.insertRepetition(37, rep);
2026     }
2027 
2028 
2029     /**
2030      * Removes a repetition of
2031      * OM1-37: "Fixed Canned Message" at a specific index
2032      *
2033      * @param rep The repetition index (0-indexed)
2034      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2035      */
2036     public CE removeFixedCannedMessage(int rep) throws HL7Exception { 
2037         return (CE) super.removeRepetition(37, rep);
2038     }
2039 
2040 
2041     /**
2042      * Removes a repetition of
2043      * OM1-37: "Fixed Canned Message" at a specific index
2044      *
2045      * @param rep The repetition index (0-indexed)
2046      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2047      */
2048     public CE removeOm137_FixedCannedMessage(int rep) throws HL7Exception { 
2049         return (CE) super.removeRepetition(37, rep);
2050     }
2051 
2052 
2053 
2054 
2055     /**
2056      * Returns
2057      * OM1-38: "Patient Preparation" - creates it if necessary
2058      */
2059     public TX getPatientPreparation() { 
2060 		TX retVal = this.getTypedField(38, 0);
2061 		return retVal;
2062     }
2063     
2064     /**
2065      * Returns
2066      * OM1-38: "Patient Preparation" - creates it if necessary
2067      */
2068     public TX getOm138_PatientPreparation() { 
2069 		TX retVal = this.getTypedField(38, 0);
2070 		return retVal;
2071     }
2072 
2073 
2074 
2075     /**
2076      * Returns
2077      * OM1-39: "Procedure Medication" - creates it if necessary
2078      */
2079     public CE getProcedureMedication() { 
2080 		CE retVal = this.getTypedField(39, 0);
2081 		return retVal;
2082     }
2083     
2084     /**
2085      * Returns
2086      * OM1-39: "Procedure Medication" - creates it if necessary
2087      */
2088     public CE getOm139_ProcedureMedication() { 
2089 		CE retVal = this.getTypedField(39, 0);
2090 		return retVal;
2091     }
2092 
2093 
2094 
2095     /**
2096      * Returns
2097      * OM1-40: "Factors that may affect the observation" - creates it if necessary
2098      */
2099     public TX getFactorsThatMayAffectTheObservation() { 
2100 		TX retVal = this.getTypedField(40, 0);
2101 		return retVal;
2102     }
2103     
2104     /**
2105      * Returns
2106      * OM1-40: "Factors that may affect the observation" - creates it if necessary
2107      */
2108     public TX getOm140_FactorsThatMayAffectTheObservation() { 
2109 		TX retVal = this.getTypedField(40, 0);
2110 		return retVal;
2111     }
2112 
2113 
2114     /**
2115      * Returns all repetitions of Test / observation performance schedule (OM1-41).
2116      */
2117     public ST[] getTestObservationPerformanceSchedule() {
2118     	ST[] retVal = this.getTypedField(41, new ST[0]);
2119     	return retVal;
2120     }
2121 
2122 
2123     /**
2124      * Returns all repetitions of Test / observation performance schedule (OM1-41).
2125      */
2126     public ST[] getOm141_TestObservationPerformanceSchedule() {
2127     	ST[] retVal = this.getTypedField(41, new ST[0]);
2128     	return retVal;
2129     }
2130 
2131 
2132     /**
2133      * Returns a count of the current number of repetitions of Test / observation performance schedule (OM1-41).
2134      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2135      * it will return zero.
2136      */
2137     public int getTestObservationPerformanceScheduleReps() {
2138     	return this.getReps(41);
2139     }
2140 
2141 
2142     /**
2143      * Returns a specific repetition of
2144      * OM1-41: "Test / observation performance schedule" - creates it if necessary
2145      *
2146      * @param rep The repetition index (0-indexed)
2147      */
2148     public ST getTestObservationPerformanceSchedule(int rep) { 
2149 		ST retVal = this.getTypedField(41, rep);
2150 		return retVal;
2151     }
2152 
2153     /**
2154      * Returns a specific repetition of
2155      * OM1-41: "Test / observation performance schedule" - creates it if necessary
2156      *
2157      * @param rep The repetition index (0-indexed)
2158      */
2159     public ST getOm141_TestObservationPerformanceSchedule(int rep) { 
2160 		ST retVal = this.getTypedField(41, rep);
2161 		return retVal;
2162     }
2163 
2164     /**
2165      * Returns a count of the current number of repetitions of Test / observation performance schedule (OM1-41).
2166      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2167      * it will return zero.
2168      */
2169     public int getOm141_TestObservationPerformanceScheduleReps() {
2170     	return this.getReps(41);
2171     }
2172 
2173 
2174     /**
2175      * Inserts a repetition of
2176      * OM1-41: "Test / observation performance schedule" at a specific index
2177      *
2178      * @param rep The repetition index (0-indexed)
2179      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2180      */
2181     public ST insertTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2182         return (ST) super.insertRepetition(41, rep);
2183     }
2184 
2185 
2186     /**
2187      * Inserts a repetition of
2188      * OM1-41: "Test / observation performance schedule" at a specific index
2189      *
2190      * @param rep The repetition index (0-indexed)
2191      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2192      */
2193     public ST insertOm141_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2194         return (ST) super.insertRepetition(41, rep);
2195     }
2196 
2197 
2198     /**
2199      * Removes a repetition of
2200      * OM1-41: "Test / observation performance schedule" at a specific index
2201      *
2202      * @param rep The repetition index (0-indexed)
2203      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2204      */
2205     public ST removeTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2206         return (ST) super.removeRepetition(41, rep);
2207     }
2208 
2209 
2210     /**
2211      * Removes a repetition of
2212      * OM1-41: "Test / observation performance schedule" at a specific index
2213      *
2214      * @param rep The repetition index (0-indexed)
2215      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2216      */
2217     public ST removeOm141_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2218         return (ST) super.removeRepetition(41, rep);
2219     }
2220 
2221 
2222 
2223 
2224     /**
2225      * Returns
2226      * OM1-42: "Description of Test Methods" - creates it if necessary
2227      */
2228     public TX getDescriptionOfTestMethods() { 
2229 		TX retVal = this.getTypedField(42, 0);
2230 		return retVal;
2231     }
2232     
2233     /**
2234      * Returns
2235      * OM1-42: "Description of Test Methods" - creates it if necessary
2236      */
2237     public TX getOm142_DescriptionOfTestMethods() { 
2238 		TX retVal = this.getTypedField(42, 0);
2239 		return retVal;
2240     }
2241 
2242 
2243 
2244 
2245 
2246     /** {@inheritDoc} */   
2247     protected Type createNewTypeWithoutReflection(int field) {
2248        switch (field) {
2249           case 0: return new ST(getMessage());
2250           case 1: return new NM(getMessage());
2251           case 2: return new CE(getMessage());
2252           case 3: return new ID(getMessage(), new Integer( 125 ));
2253           case 4: return new ID(getMessage(), new Integer( 136 ));
2254           case 5: return new CE(getMessage());
2255           case 6: return new TX(getMessage());
2256           case 7: return new CE(getMessage());
2257           case 8: return new ST(getMessage());
2258           case 9: return new ST(getMessage());
2259           case 10: return new ST(getMessage());
2260           case 11: return new ST(getMessage());
2261           case 12: return new ID(getMessage(), new Integer( 136 ));
2262           case 13: return new CE(getMessage());
2263           case 14: return new CE(getMessage());
2264           case 15: return new ID(getMessage(), new Integer( 136 ));
2265           case 16: return new ID(getMessage(), new Integer( 0 ));
2266           case 17: return new TN(getMessage());
2267           case 18: return new ID(getMessage(), new Integer( 174 ));
2268           case 19: return new CE(getMessage());
2269           case 20: return new ST(getMessage());
2270           case 21: return new TS(getMessage());
2271           case 22: return new TS(getMessage());
2272           case 23: return new NM(getMessage());
2273           case 24: return new NM(getMessage());
2274           case 25: return new ID(getMessage(), new Integer( 168 ));
2275           case 26: return new ID(getMessage(), new Integer( 169 ));
2276           case 27: return new CE(getMessage());
2277           case 28: return new AD(getMessage());
2278           case 29: return new TN(getMessage());
2279           case 30: return new ID(getMessage(), new Integer( 177 ));
2280           case 31: return new CE(getMessage());
2281           case 32: return new TX(getMessage());
2282           case 33: return new CE(getMessage());
2283           case 34: return new CE(getMessage());
2284           case 35: return new ST(getMessage());
2285           case 36: return new CE(getMessage());
2286           case 37: return new TX(getMessage());
2287           case 38: return new CE(getMessage());
2288           case 39: return new TX(getMessage());
2289           case 40: return new ST(getMessage());
2290           case 41: return new TX(getMessage());
2291           default: return null;
2292        }
2293    }
2294 
2295 
2296 }
2297