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.v23.segment;
35  
36  // import ca.uhn.hl7v2.model.v23.group.*;
37  import ca.uhn.hl7v2.model.v23.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: Sequence Number - Test/ Observation Master File (NM) <b>optional </b>
53       * <li>OM1-2: Producer's Test/Observation ID (CE) <b> </b>
54       * <li>OM1-3: Permitted Data Types (ID) <b>optional repeating</b>
55       * <li>OM1-4: Specimen Required (ID) <b> </b>
56       * <li>OM1-5: Producer ID (CE) <b> </b>
57       * <li>OM1-6: Observation Description (CE) <b>optional </b>
58       * <li>OM1-7: Other Test/Observation IDs for the Observation (CE) <b>optional </b>
59       * <li>OM1-8: Other Names (ST) <b> repeating</b>
60       * <li>OM1-9: Preferred Report Name for the Observation (ST) <b>optional </b>
61       * <li>OM1-10: Preferred Short Name or Mnemonic for Observation (ST) <b>optional </b>
62       * <li>OM1-11: Preferred Long Name for the Observation (ST) <b>optional </b>
63       * <li>OM1-12: Orderability (ID) <b>optional </b>
64       * <li>OM1-13: Identity of Instrument Used to Perfrom this Study (CE) <b>optional repeating</b>
65       * <li>OM1-14: Coded Representation of Method (CE) <b>optional </b>
66       * <li>OM1-15: Portable (ID) <b>optional </b>
67       * <li>OM1-16: Observation Producing Department/Section (CE) <b>optional repeating</b>
68       * <li>OM1-17: Telephone Number of Section (TN) <b>optional </b>
69       * <li>OM1-18: Nature of Test/Observation (ID) <b>optional </b>
70       * <li>OM1-19: Report Subheader (CE) <b>optional </b>
71       * <li>OM1-20: Report Display Order (ST) <b>optional </b>
72       * <li>OM1-21: Date/Time Stamp for any change in Def Attri for Obs (TS) <b>optional </b>
73       * <li>OM1-22: Effective Date/Time of Change in Test Proc. that make Results Non-Comparable (TS) <b>optional </b>
74       * <li>OM1-23: Typical Turn-Around Time (NM) <b>optional </b>
75       * <li>OM1-24: Processing Time (NM) <b>optional </b>
76       * <li>OM1-25: Processing Priority (ID) <b>optional repeating</b>
77       * <li>OM1-26: Reporting Priority (ID) <b>optional </b>
78       * <li>OM1-27: Outside Site(s) Where Observation may be Performed (CE) <b>optional repeating</b>
79       * <li>OM1-28: Address of Outside Site(s) (AD) <b>optional </b>
80       * <li>OM1-29: Phone Number of Outside Site (TN) <b>optional </b>
81       * <li>OM1-30: Confidentiality Code (ID) <b>optional </b>
82       * <li>OM1-31: Observations Required to Interpret the Observation (CE) <b>optional </b>
83       * <li>OM1-32: Interpretation of Observations (TX) <b>optional </b>
84       * <li>OM1-33: Contraindications to Observations (CE) <b>optional </b>
85       * <li>OM1-34: Reflex Tests/Observations (CE) <b>optional repeating</b>
86       * <li>OM1-35: Rules that Trigger Reflex Testing (ST) <b>optional </b>
87       * <li>OM1-36: Fixed Canned Message (CE) <b>optional </b>
88       * <li>OM1-37: Patient Preparation (TX) <b>optional </b>
89       * <li>OM1-38: Procedure Medication (CE) <b>optional </b>
90       * <li>OM1-39: Factors that may Effect the Observation (TX) <b>optional </b>
91       * <li>OM1-40: Test/Observation Performance Schedule (ST) <b>optional repeating</b>
92       * <li>OM1-41: Description of Test Methods (TX) <b>optional </b>
93       * <li>OM1-42: Kind of Quantity Observed (CE) <b>optional </b>
94       * <li>OM1-43: Point versus Interval (CE) <b>optional </b>
95       * <li>OM1-44: Challenge information (TX) <b>optional </b>
96       * <li>OM1-45: Relationship modifier (CE) <b>optional </b>
97       * <li>OM1-46: Target anatomic site of test (CE) <b>optional </b>
98       * <li>OM1-47: Modality of imaging measurement (CE) <b>optional </b>
99   * </ul>
100  */
101 @SuppressWarnings("unused")
102 public class OM1 extends AbstractSegment {
103 
104     /** 
105      * Creates a new OM1 segment
106      */
107     public OM1(Group parent, ModelClassFactory factory) {
108        super(parent, factory);
109        init(factory);
110     }
111 
112     private void init(ModelClassFactory factory) {
113        try {
114                                   this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Sequence Number - Test/ Observation Master File");
115                                   this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer's Test/Observation ID");
116                                               this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(125) }, "Permitted Data Types");
117                                               this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Specimen Required");
118                                   this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer ID");
119                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Observation Description");
120                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Other Test/Observation IDs for the Observation");
121                                   this.add(ST.class, true, 0, 200, new Object[]{ getMessage() }, "Other Names");
122                                   this.add(ST.class, false, 1, 30, new Object[]{ getMessage() }, "Preferred Report Name for the Observation");
123                                   this.add(ST.class, false, 1, 8, new Object[]{ getMessage() }, "Preferred Short Name or Mnemonic for Observation");
124                                   this.add(ST.class, false, 1, 200, new Object[]{ getMessage() }, "Preferred Long Name for the Observation");
125                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Orderability");
126                                   this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Identity of Instrument Used to Perfrom this Study");
127                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Coded Representation of Method");
128                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Portable");
129                                   this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Observation Producing Department/Section");
130                                   this.add(TN.class, false, 1, 40, new Object[]{ getMessage() }, "Telephone Number of Section");
131                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(174) }, "Nature of Test/Observation");
132                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Report Subheader");
133                                   this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Report Display Order");
134                                   this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time Stamp for any change in Def Attri for Obs");
135                                   this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable");
136                                   this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Typical Turn-Around Time");
137                                   this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Processing Time");
138                                               this.add(ID.class, false, 0, 40, new Object[]{ getMessage(), new Integer(168) }, "Processing Priority");
139                                               this.add(ID.class, false, 1, 5, new Object[]{ getMessage(), new Integer(169) }, "Reporting Priority");
140                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Outside Site(s) Where Observation may be Performed");
141                                   this.add(AD.class, false, 1, 1000, new Object[]{ getMessage() }, "Address of Outside Site(s)");
142                                   this.add(TN.class, false, 1, 400, new Object[]{ getMessage() }, "Phone Number of Outside Site");
143                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(177) }, "Confidentiality Code");
144                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Observations Required to Interpret the Observation");
145                                   this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Interpretation of Observations");
146                                   this.add(CE.class, false, 1, 65536, new Object[]{ getMessage() }, "Contraindications to Observations");
147                                   this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Reflex Tests/Observations");
148                                   this.add(ST.class, false, 1, 80, new Object[]{ getMessage() }, "Rules that Trigger Reflex Testing");
149                                   this.add(CE.class, false, 1, 65536, new Object[]{ getMessage() }, "Fixed Canned Message");
150                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Patient Preparation");
151                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Procedure Medication");
152                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Factors that may Effect the Observation");
153                                   this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Test/Observation Performance Schedule");
154                                   this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Description of Test Methods");
155                                   this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Kind of Quantity Observed");
156                                   this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Point versus Interval");
157                                   this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Challenge information");
158                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Relationship modifier");
159                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Target anatomic site of test");
160                                   this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Modality of imaging measurement");
161        } catch(HL7Exception e) {
162           log.error("Unexpected error creating OM1 - this is probably a bug in the source code generator.", e);
163        }
164     }
165 
166 
167 
168     /**
169      * Returns
170      * OM1-1: "Sequence Number - Test/ Observation Master File" - creates it if necessary
171      */
172     public NM getSequenceNumberTestObservationMasterFile() { 
173 		NM retVal = this.getTypedField(1, 0);
174 		return retVal;
175     }
176     
177     /**
178      * Returns
179      * OM1-1: "Sequence Number - Test/ Observation Master File" - creates it if necessary
180      */
181     public NM getOm11_SequenceNumberTestObservationMasterFile() { 
182 		NM retVal = this.getTypedField(1, 0);
183 		return retVal;
184     }
185 
186 
187 
188     /**
189      * Returns
190      * OM1-2: "Producer's Test/Observation ID" - creates it if necessary
191      */
192     public CE getProducerSTestObservationID() { 
193 		CE retVal = this.getTypedField(2, 0);
194 		return retVal;
195     }
196     
197     /**
198      * Returns
199      * OM1-2: "Producer's Test/Observation ID" - creates it if necessary
200      */
201     public CE getOm12_ProducerSTestObservationID() { 
202 		CE retVal = this.getTypedField(2, 0);
203 		return retVal;
204     }
205 
206 
207     /**
208      * Returns all repetitions of Permitted Data Types (OM1-3).
209      */
210     public ID[] getPermittedDataTypes() {
211     	ID[] retVal = this.getTypedField(3, new ID[0]);
212     	return retVal;
213     }
214 
215 
216     /**
217      * Returns all repetitions of Permitted Data Types (OM1-3).
218      */
219     public ID[] getOm13_PermittedDataTypes() {
220     	ID[] retVal = this.getTypedField(3, new ID[0]);
221     	return retVal;
222     }
223 
224 
225     /**
226      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3).
227      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
228      * it will return zero.
229      */
230     public int getPermittedDataTypesReps() {
231     	return this.getReps(3);
232     }
233 
234 
235     /**
236      * Returns a specific repetition of
237      * OM1-3: "Permitted Data Types" - creates it if necessary
238      *
239      * @param rep The repetition index (0-indexed)
240      */
241     public ID getPermittedDataTypes(int rep) { 
242 		ID retVal = this.getTypedField(3, rep);
243 		return retVal;
244     }
245 
246     /**
247      * Returns a specific repetition of
248      * OM1-3: "Permitted Data Types" - creates it if necessary
249      *
250      * @param rep The repetition index (0-indexed)
251      */
252     public ID getOm13_PermittedDataTypes(int rep) { 
253 		ID retVal = this.getTypedField(3, rep);
254 		return retVal;
255     }
256 
257     /**
258      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3).
259      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
260      * it will return zero.
261      */
262     public int getOm13_PermittedDataTypesReps() {
263     	return this.getReps(3);
264     }
265 
266 
267     /**
268      * Inserts a repetition of
269      * OM1-3: "Permitted Data Types" at a specific index
270      *
271      * @param rep The repetition index (0-indexed)
272      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
273      */
274     public ID insertPermittedDataTypes(int rep) throws HL7Exception { 
275         return (ID) super.insertRepetition(3, rep);
276     }
277 
278 
279     /**
280      * Inserts a repetition of
281      * OM1-3: "Permitted Data Types" at a specific index
282      *
283      * @param rep The repetition index (0-indexed)
284      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
285      */
286     public ID insertOm13_PermittedDataTypes(int rep) throws HL7Exception { 
287         return (ID) super.insertRepetition(3, rep);
288     }
289 
290 
291     /**
292      * Removes a repetition of
293      * OM1-3: "Permitted Data Types" at a specific index
294      *
295      * @param rep The repetition index (0-indexed)
296      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
297      */
298     public ID removePermittedDataTypes(int rep) throws HL7Exception { 
299         return (ID) super.removeRepetition(3, rep);
300     }
301 
302 
303     /**
304      * Removes a repetition of
305      * OM1-3: "Permitted Data Types" at a specific index
306      *
307      * @param rep The repetition index (0-indexed)
308      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
309      */
310     public ID removeOm13_PermittedDataTypes(int rep) throws HL7Exception { 
311         return (ID) super.removeRepetition(3, rep);
312     }
313 
314 
315 
316 
317     /**
318      * Returns
319      * OM1-4: "Specimen Required" - creates it if necessary
320      */
321     public ID getSpecimenRequired() { 
322 		ID retVal = this.getTypedField(4, 0);
323 		return retVal;
324     }
325     
326     /**
327      * Returns
328      * OM1-4: "Specimen Required" - creates it if necessary
329      */
330     public ID getOm14_SpecimenRequired() { 
331 		ID retVal = this.getTypedField(4, 0);
332 		return retVal;
333     }
334 
335 
336 
337     /**
338      * Returns
339      * OM1-5: "Producer ID" - creates it if necessary
340      */
341     public CE getProducerID() { 
342 		CE retVal = this.getTypedField(5, 0);
343 		return retVal;
344     }
345     
346     /**
347      * Returns
348      * OM1-5: "Producer ID" - creates it if necessary
349      */
350     public CE getOm15_ProducerID() { 
351 		CE retVal = this.getTypedField(5, 0);
352 		return retVal;
353     }
354 
355 
356 
357     /**
358      * Returns
359      * OM1-6: "Observation Description" - creates it if necessary
360      */
361     public CE getObservationDescription() { 
362 		CE retVal = this.getTypedField(6, 0);
363 		return retVal;
364     }
365     
366     /**
367      * Returns
368      * OM1-6: "Observation Description" - creates it if necessary
369      */
370     public CE getOm16_ObservationDescription() { 
371 		CE retVal = this.getTypedField(6, 0);
372 		return retVal;
373     }
374 
375 
376 
377     /**
378      * Returns
379      * OM1-7: "Other Test/Observation IDs for the Observation" - creates it if necessary
380      */
381     public CE getOtherTestObservationIDsForTheObservation() { 
382 		CE retVal = this.getTypedField(7, 0);
383 		return retVal;
384     }
385     
386     /**
387      * Returns
388      * OM1-7: "Other Test/Observation IDs for the Observation" - creates it if necessary
389      */
390     public CE getOm17_OtherTestObservationIDsForTheObservation() { 
391 		CE retVal = this.getTypedField(7, 0);
392 		return retVal;
393     }
394 
395 
396     /**
397      * Returns all repetitions of Other Names (OM1-8).
398      */
399     public ST[] getOtherNames() {
400     	ST[] retVal = this.getTypedField(8, new ST[0]);
401     	return retVal;
402     }
403 
404 
405     /**
406      * Returns all repetitions of Other Names (OM1-8).
407      */
408     public ST[] getOm18_OtherNames() {
409     	ST[] retVal = this.getTypedField(8, new ST[0]);
410     	return retVal;
411     }
412 
413 
414     /**
415      * Returns a count of the current number of repetitions of Other Names (OM1-8).
416      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
417      * it will return zero.
418      */
419     public int getOtherNamesReps() {
420     	return this.getReps(8);
421     }
422 
423 
424     /**
425      * Returns a specific repetition of
426      * OM1-8: "Other Names" - creates it if necessary
427      *
428      * @param rep The repetition index (0-indexed)
429      */
430     public ST getOtherNames(int rep) { 
431 		ST retVal = this.getTypedField(8, rep);
432 		return retVal;
433     }
434 
435     /**
436      * Returns a specific repetition of
437      * OM1-8: "Other Names" - creates it if necessary
438      *
439      * @param rep The repetition index (0-indexed)
440      */
441     public ST getOm18_OtherNames(int rep) { 
442 		ST retVal = this.getTypedField(8, rep);
443 		return retVal;
444     }
445 
446     /**
447      * Returns a count of the current number of repetitions of Other Names (OM1-8).
448      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
449      * it will return zero.
450      */
451     public int getOm18_OtherNamesReps() {
452     	return this.getReps(8);
453     }
454 
455 
456     /**
457      * Inserts a repetition of
458      * OM1-8: "Other Names" at a specific index
459      *
460      * @param rep The repetition index (0-indexed)
461      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
462      */
463     public ST insertOtherNames(int rep) throws HL7Exception { 
464         return (ST) super.insertRepetition(8, rep);
465     }
466 
467 
468     /**
469      * Inserts a repetition of
470      * OM1-8: "Other Names" at a specific index
471      *
472      * @param rep The repetition index (0-indexed)
473      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
474      */
475     public ST insertOm18_OtherNames(int rep) throws HL7Exception { 
476         return (ST) super.insertRepetition(8, rep);
477     }
478 
479 
480     /**
481      * Removes a repetition of
482      * OM1-8: "Other Names" at a specific index
483      *
484      * @param rep The repetition index (0-indexed)
485      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
486      */
487     public ST removeOtherNames(int rep) throws HL7Exception { 
488         return (ST) super.removeRepetition(8, rep);
489     }
490 
491 
492     /**
493      * Removes a repetition of
494      * OM1-8: "Other Names" at a specific index
495      *
496      * @param rep The repetition index (0-indexed)
497      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
498      */
499     public ST removeOm18_OtherNames(int rep) throws HL7Exception { 
500         return (ST) super.removeRepetition(8, rep);
501     }
502 
503 
504 
505 
506     /**
507      * Returns
508      * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary
509      */
510     public ST getPreferredReportNameForTheObservation() { 
511 		ST retVal = this.getTypedField(9, 0);
512 		return retVal;
513     }
514     
515     /**
516      * Returns
517      * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary
518      */
519     public ST getOm19_PreferredReportNameForTheObservation() { 
520 		ST retVal = this.getTypedField(9, 0);
521 		return retVal;
522     }
523 
524 
525 
526     /**
527      * Returns
528      * OM1-10: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary
529      */
530     public ST getPreferredShortNameOrMnemonicForObservation() { 
531 		ST retVal = this.getTypedField(10, 0);
532 		return retVal;
533     }
534     
535     /**
536      * Returns
537      * OM1-10: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary
538      */
539     public ST getOm110_PreferredShortNameOrMnemonicForObservation() { 
540 		ST retVal = this.getTypedField(10, 0);
541 		return retVal;
542     }
543 
544 
545 
546     /**
547      * Returns
548      * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary
549      */
550     public ST getPreferredLongNameForTheObservation() { 
551 		ST retVal = this.getTypedField(11, 0);
552 		return retVal;
553     }
554     
555     /**
556      * Returns
557      * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary
558      */
559     public ST getOm111_PreferredLongNameForTheObservation() { 
560 		ST retVal = this.getTypedField(11, 0);
561 		return retVal;
562     }
563 
564 
565 
566     /**
567      * Returns
568      * OM1-12: "Orderability" - creates it if necessary
569      */
570     public ID getOrderability() { 
571 		ID retVal = this.getTypedField(12, 0);
572 		return retVal;
573     }
574     
575     /**
576      * Returns
577      * OM1-12: "Orderability" - creates it if necessary
578      */
579     public ID getOm112_Orderability() { 
580 		ID retVal = this.getTypedField(12, 0);
581 		return retVal;
582     }
583 
584 
585     /**
586      * Returns all repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13).
587      */
588     public CE[] getIdentityOfInstrumentUsedToPerfromThisStudy() {
589     	CE[] retVal = this.getTypedField(13, new CE[0]);
590     	return retVal;
591     }
592 
593 
594     /**
595      * Returns all repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13).
596      */
597     public CE[] getOm113_IdentityOfInstrumentUsedToPerfromThisStudy() {
598     	CE[] retVal = this.getTypedField(13, new CE[0]);
599     	return retVal;
600     }
601 
602 
603     /**
604      * Returns a count of the current number of repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13).
605      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
606      * it will return zero.
607      */
608     public int getIdentityOfInstrumentUsedToPerfromThisStudyReps() {
609     	return this.getReps(13);
610     }
611 
612 
613     /**
614      * Returns a specific repetition of
615      * OM1-13: "Identity of Instrument Used to Perfrom this Study" - creates it if necessary
616      *
617      * @param rep The repetition index (0-indexed)
618      */
619     public CE getIdentityOfInstrumentUsedToPerfromThisStudy(int rep) { 
620 		CE retVal = this.getTypedField(13, rep);
621 		return retVal;
622     }
623 
624     /**
625      * Returns a specific repetition of
626      * OM1-13: "Identity of Instrument Used to Perfrom this Study" - creates it if necessary
627      *
628      * @param rep The repetition index (0-indexed)
629      */
630     public CE getOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) { 
631 		CE retVal = this.getTypedField(13, rep);
632 		return retVal;
633     }
634 
635     /**
636      * Returns a count of the current number of repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13).
637      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
638      * it will return zero.
639      */
640     public int getOm113_IdentityOfInstrumentUsedToPerfromThisStudyReps() {
641     	return this.getReps(13);
642     }
643 
644 
645     /**
646      * Inserts a repetition of
647      * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index
648      *
649      * @param rep The repetition index (0-indexed)
650      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
651      */
652     public CE insertIdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 
653         return (CE) super.insertRepetition(13, rep);
654     }
655 
656 
657     /**
658      * Inserts a repetition of
659      * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index
660      *
661      * @param rep The repetition index (0-indexed)
662      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
663      */
664     public CE insertOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 
665         return (CE) super.insertRepetition(13, rep);
666     }
667 
668 
669     /**
670      * Removes a repetition of
671      * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index
672      *
673      * @param rep The repetition index (0-indexed)
674      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
675      */
676     public CE removeIdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 
677         return (CE) super.removeRepetition(13, rep);
678     }
679 
680 
681     /**
682      * Removes a repetition of
683      * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index
684      *
685      * @param rep The repetition index (0-indexed)
686      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
687      */
688     public CE removeOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 
689         return (CE) super.removeRepetition(13, rep);
690     }
691 
692 
693 
694 
695     /**
696      * Returns
697      * OM1-14: "Coded Representation of Method" - creates it if necessary
698      */
699     public CE getCodedRepresentationOfMethod() { 
700 		CE retVal = this.getTypedField(14, 0);
701 		return retVal;
702     }
703     
704     /**
705      * Returns
706      * OM1-14: "Coded Representation of Method" - creates it if necessary
707      */
708     public CE getOm114_CodedRepresentationOfMethod() { 
709 		CE retVal = this.getTypedField(14, 0);
710 		return retVal;
711     }
712 
713 
714 
715     /**
716      * Returns
717      * OM1-15: "Portable" - creates it if necessary
718      */
719     public ID getPortable() { 
720 		ID retVal = this.getTypedField(15, 0);
721 		return retVal;
722     }
723     
724     /**
725      * Returns
726      * OM1-15: "Portable" - creates it if necessary
727      */
728     public ID getOm115_Portable() { 
729 		ID retVal = this.getTypedField(15, 0);
730 		return retVal;
731     }
732 
733 
734     /**
735      * Returns all repetitions of Observation Producing Department/Section (OM1-16).
736      */
737     public CE[] getObservationProducingDepartmentSection() {
738     	CE[] retVal = this.getTypedField(16, new CE[0]);
739     	return retVal;
740     }
741 
742 
743     /**
744      * Returns all repetitions of Observation Producing Department/Section (OM1-16).
745      */
746     public CE[] getOm116_ObservationProducingDepartmentSection() {
747     	CE[] retVal = this.getTypedField(16, new CE[0]);
748     	return retVal;
749     }
750 
751 
752     /**
753      * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16).
754      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
755      * it will return zero.
756      */
757     public int getObservationProducingDepartmentSectionReps() {
758     	return this.getReps(16);
759     }
760 
761 
762     /**
763      * Returns a specific repetition of
764      * OM1-16: "Observation Producing Department/Section" - creates it if necessary
765      *
766      * @param rep The repetition index (0-indexed)
767      */
768     public CE getObservationProducingDepartmentSection(int rep) { 
769 		CE retVal = this.getTypedField(16, rep);
770 		return retVal;
771     }
772 
773     /**
774      * Returns a specific repetition of
775      * OM1-16: "Observation Producing Department/Section" - creates it if necessary
776      *
777      * @param rep The repetition index (0-indexed)
778      */
779     public CE getOm116_ObservationProducingDepartmentSection(int rep) { 
780 		CE retVal = this.getTypedField(16, rep);
781 		return retVal;
782     }
783 
784     /**
785      * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16).
786      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
787      * it will return zero.
788      */
789     public int getOm116_ObservationProducingDepartmentSectionReps() {
790     	return this.getReps(16);
791     }
792 
793 
794     /**
795      * Inserts a repetition of
796      * OM1-16: "Observation Producing Department/Section" at a specific index
797      *
798      * @param rep The repetition index (0-indexed)
799      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
800      */
801     public CE insertObservationProducingDepartmentSection(int rep) throws HL7Exception { 
802         return (CE) super.insertRepetition(16, rep);
803     }
804 
805 
806     /**
807      * Inserts a repetition of
808      * OM1-16: "Observation Producing Department/Section" at a specific index
809      *
810      * @param rep The repetition index (0-indexed)
811      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
812      */
813     public CE insertOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
814         return (CE) super.insertRepetition(16, rep);
815     }
816 
817 
818     /**
819      * Removes a repetition of
820      * OM1-16: "Observation Producing Department/Section" at a specific index
821      *
822      * @param rep The repetition index (0-indexed)
823      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
824      */
825     public CE removeObservationProducingDepartmentSection(int rep) throws HL7Exception { 
826         return (CE) super.removeRepetition(16, rep);
827     }
828 
829 
830     /**
831      * Removes a repetition of
832      * OM1-16: "Observation Producing Department/Section" at a specific index
833      *
834      * @param rep The repetition index (0-indexed)
835      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
836      */
837     public CE removeOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
838         return (CE) super.removeRepetition(16, rep);
839     }
840 
841 
842 
843 
844     /**
845      * Returns
846      * OM1-17: "Telephone Number of Section" - creates it if necessary
847      */
848     public TN getTelephoneNumberOfSection() { 
849 		TN retVal = this.getTypedField(17, 0);
850 		return retVal;
851     }
852     
853     /**
854      * Returns
855      * OM1-17: "Telephone Number of Section" - creates it if necessary
856      */
857     public TN getOm117_TelephoneNumberOfSection() { 
858 		TN retVal = this.getTypedField(17, 0);
859 		return retVal;
860     }
861 
862 
863 
864     /**
865      * Returns
866      * OM1-18: "Nature of Test/Observation" - creates it if necessary
867      */
868     public ID getNatureOfTestObservation() { 
869 		ID retVal = this.getTypedField(18, 0);
870 		return retVal;
871     }
872     
873     /**
874      * Returns
875      * OM1-18: "Nature of Test/Observation" - creates it if necessary
876      */
877     public ID getOm118_NatureOfTestObservation() { 
878 		ID retVal = this.getTypedField(18, 0);
879 		return retVal;
880     }
881 
882 
883 
884     /**
885      * Returns
886      * OM1-19: "Report Subheader" - creates it if necessary
887      */
888     public CE getReportSubheader() { 
889 		CE retVal = this.getTypedField(19, 0);
890 		return retVal;
891     }
892     
893     /**
894      * Returns
895      * OM1-19: "Report Subheader" - creates it if necessary
896      */
897     public CE getOm119_ReportSubheader() { 
898 		CE retVal = this.getTypedField(19, 0);
899 		return retVal;
900     }
901 
902 
903 
904     /**
905      * Returns
906      * OM1-20: "Report Display Order" - creates it if necessary
907      */
908     public ST getReportDisplayOrder() { 
909 		ST retVal = this.getTypedField(20, 0);
910 		return retVal;
911     }
912     
913     /**
914      * Returns
915      * OM1-20: "Report Display Order" - creates it if necessary
916      */
917     public ST getOm120_ReportDisplayOrder() { 
918 		ST retVal = this.getTypedField(20, 0);
919 		return retVal;
920     }
921 
922 
923 
924     /**
925      * Returns
926      * OM1-21: "Date/Time Stamp for any change in Def Attri for Obs" - creates it if necessary
927      */
928     public TS getDateTimeStampForAnyChangeInDefAttriForObs() { 
929 		TS retVal = this.getTypedField(21, 0);
930 		return retVal;
931     }
932     
933     /**
934      * Returns
935      * OM1-21: "Date/Time Stamp for any change in Def Attri for Obs" - creates it if necessary
936      */
937     public TS getOm121_DateTimeStampForAnyChangeInDefAttriForObs() { 
938 		TS retVal = this.getTypedField(21, 0);
939 		return retVal;
940     }
941 
942 
943 
944     /**
945      * Returns
946      * OM1-22: "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable" - creates it if necessary
947      */
948     public TS getEffectiveDateTimeOfChangeInTestProcThatMakeResultsNonComparable() { 
949 		TS retVal = this.getTypedField(22, 0);
950 		return retVal;
951     }
952     
953     /**
954      * Returns
955      * OM1-22: "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable" - creates it if necessary
956      */
957     public TS getOm122_EffectiveDateTimeOfChangeInTestProcThatMakeResultsNonComparable() { 
958 		TS retVal = this.getTypedField(22, 0);
959 		return retVal;
960     }
961 
962 
963 
964     /**
965      * Returns
966      * OM1-23: "Typical Turn-Around Time" - creates it if necessary
967      */
968     public NM getTypicalTurnAroundTime() { 
969 		NM retVal = this.getTypedField(23, 0);
970 		return retVal;
971     }
972     
973     /**
974      * Returns
975      * OM1-23: "Typical Turn-Around Time" - creates it if necessary
976      */
977     public NM getOm123_TypicalTurnAroundTime() { 
978 		NM retVal = this.getTypedField(23, 0);
979 		return retVal;
980     }
981 
982 
983 
984     /**
985      * Returns
986      * OM1-24: "Processing Time" - creates it if necessary
987      */
988     public NM getProcessingTime() { 
989 		NM retVal = this.getTypedField(24, 0);
990 		return retVal;
991     }
992     
993     /**
994      * Returns
995      * OM1-24: "Processing Time" - creates it if necessary
996      */
997     public NM getOm124_ProcessingTime() { 
998 		NM retVal = this.getTypedField(24, 0);
999 		return retVal;
1000     }
1001 
1002 
1003     /**
1004      * Returns all repetitions of Processing Priority (OM1-25).
1005      */
1006     public ID[] getProcessingPriority() {
1007     	ID[] retVal = this.getTypedField(25, new ID[0]);
1008     	return retVal;
1009     }
1010 
1011 
1012     /**
1013      * Returns all repetitions of Processing Priority (OM1-25).
1014      */
1015     public ID[] getOm125_ProcessingPriority() {
1016     	ID[] retVal = this.getTypedField(25, new ID[0]);
1017     	return retVal;
1018     }
1019 
1020 
1021     /**
1022      * Returns a count of the current number of repetitions of Processing Priority (OM1-25).
1023      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1024      * it will return zero.
1025      */
1026     public int getProcessingPriorityReps() {
1027     	return this.getReps(25);
1028     }
1029 
1030 
1031     /**
1032      * Returns a specific repetition of
1033      * OM1-25: "Processing Priority" - creates it if necessary
1034      *
1035      * @param rep The repetition index (0-indexed)
1036      */
1037     public ID getProcessingPriority(int rep) { 
1038 		ID retVal = this.getTypedField(25, rep);
1039 		return retVal;
1040     }
1041 
1042     /**
1043      * Returns a specific repetition of
1044      * OM1-25: "Processing Priority" - creates it if necessary
1045      *
1046      * @param rep The repetition index (0-indexed)
1047      */
1048     public ID getOm125_ProcessingPriority(int rep) { 
1049 		ID retVal = this.getTypedField(25, rep);
1050 		return retVal;
1051     }
1052 
1053     /**
1054      * Returns a count of the current number of repetitions of Processing Priority (OM1-25).
1055      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1056      * it will return zero.
1057      */
1058     public int getOm125_ProcessingPriorityReps() {
1059     	return this.getReps(25);
1060     }
1061 
1062 
1063     /**
1064      * Inserts a repetition of
1065      * OM1-25: "Processing Priority" at a specific index
1066      *
1067      * @param rep The repetition index (0-indexed)
1068      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1069      */
1070     public ID insertProcessingPriority(int rep) throws HL7Exception { 
1071         return (ID) super.insertRepetition(25, rep);
1072     }
1073 
1074 
1075     /**
1076      * Inserts a repetition of
1077      * OM1-25: "Processing Priority" at a specific index
1078      *
1079      * @param rep The repetition index (0-indexed)
1080      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1081      */
1082     public ID insertOm125_ProcessingPriority(int rep) throws HL7Exception { 
1083         return (ID) super.insertRepetition(25, rep);
1084     }
1085 
1086 
1087     /**
1088      * Removes a repetition of
1089      * OM1-25: "Processing Priority" at a specific index
1090      *
1091      * @param rep The repetition index (0-indexed)
1092      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1093      */
1094     public ID removeProcessingPriority(int rep) throws HL7Exception { 
1095         return (ID) super.removeRepetition(25, rep);
1096     }
1097 
1098 
1099     /**
1100      * Removes a repetition of
1101      * OM1-25: "Processing Priority" at a specific index
1102      *
1103      * @param rep The repetition index (0-indexed)
1104      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1105      */
1106     public ID removeOm125_ProcessingPriority(int rep) throws HL7Exception { 
1107         return (ID) super.removeRepetition(25, rep);
1108     }
1109 
1110 
1111 
1112 
1113     /**
1114      * Returns
1115      * OM1-26: "Reporting Priority" - creates it if necessary
1116      */
1117     public ID getReportingPriority() { 
1118 		ID retVal = this.getTypedField(26, 0);
1119 		return retVal;
1120     }
1121     
1122     /**
1123      * Returns
1124      * OM1-26: "Reporting Priority" - creates it if necessary
1125      */
1126     public ID getOm126_ReportingPriority() { 
1127 		ID retVal = this.getTypedField(26, 0);
1128 		return retVal;
1129     }
1130 
1131 
1132     /**
1133      * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27).
1134      */
1135     public CE[] getOutsideSiteSWhereObservationMayBePerformed() {
1136     	CE[] retVal = this.getTypedField(27, new CE[0]);
1137     	return retVal;
1138     }
1139 
1140 
1141     /**
1142      * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27).
1143      */
1144     public CE[] getOm127_OutsideSiteSWhereObservationMayBePerformed() {
1145     	CE[] retVal = this.getTypedField(27, new CE[0]);
1146     	return retVal;
1147     }
1148 
1149 
1150     /**
1151      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27).
1152      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1153      * it will return zero.
1154      */
1155     public int getOutsideSiteSWhereObservationMayBePerformedReps() {
1156     	return this.getReps(27);
1157     }
1158 
1159 
1160     /**
1161      * Returns a specific repetition of
1162      * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary
1163      *
1164      * @param rep The repetition index (0-indexed)
1165      */
1166     public CE getOutsideSiteSWhereObservationMayBePerformed(int rep) { 
1167 		CE retVal = this.getTypedField(27, rep);
1168 		return retVal;
1169     }
1170 
1171     /**
1172      * Returns a specific repetition of
1173      * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary
1174      *
1175      * @param rep The repetition index (0-indexed)
1176      */
1177     public CE getOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) { 
1178 		CE retVal = this.getTypedField(27, rep);
1179 		return retVal;
1180     }
1181 
1182     /**
1183      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27).
1184      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1185      * it will return zero.
1186      */
1187     public int getOm127_OutsideSiteSWhereObservationMayBePerformedReps() {
1188     	return this.getReps(27);
1189     }
1190 
1191 
1192     /**
1193      * Inserts a repetition of
1194      * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index
1195      *
1196      * @param rep The repetition index (0-indexed)
1197      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1198      */
1199     public CE insertOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1200         return (CE) super.insertRepetition(27, rep);
1201     }
1202 
1203 
1204     /**
1205      * Inserts a repetition of
1206      * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index
1207      *
1208      * @param rep The repetition index (0-indexed)
1209      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1210      */
1211     public CE insertOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1212         return (CE) super.insertRepetition(27, rep);
1213     }
1214 
1215 
1216     /**
1217      * Removes a repetition of
1218      * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index
1219      *
1220      * @param rep The repetition index (0-indexed)
1221      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1222      */
1223     public CE removeOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1224         return (CE) super.removeRepetition(27, rep);
1225     }
1226 
1227 
1228     /**
1229      * Removes a repetition of
1230      * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index
1231      *
1232      * @param rep The repetition index (0-indexed)
1233      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1234      */
1235     public CE removeOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1236         return (CE) super.removeRepetition(27, rep);
1237     }
1238 
1239 
1240 
1241 
1242     /**
1243      * Returns
1244      * OM1-28: "Address of Outside Site(s)" - creates it if necessary
1245      */
1246     public AD getAddressOfOutsideSiteS() { 
1247 		AD retVal = this.getTypedField(28, 0);
1248 		return retVal;
1249     }
1250     
1251     /**
1252      * Returns
1253      * OM1-28: "Address of Outside Site(s)" - creates it if necessary
1254      */
1255     public AD getOm128_AddressOfOutsideSiteS() { 
1256 		AD retVal = this.getTypedField(28, 0);
1257 		return retVal;
1258     }
1259 
1260 
1261 
1262     /**
1263      * Returns
1264      * OM1-29: "Phone Number of Outside Site" - creates it if necessary
1265      */
1266     public TN getPhoneNumberOfOutsideSite() { 
1267 		TN retVal = this.getTypedField(29, 0);
1268 		return retVal;
1269     }
1270     
1271     /**
1272      * Returns
1273      * OM1-29: "Phone Number of Outside Site" - creates it if necessary
1274      */
1275     public TN getOm129_PhoneNumberOfOutsideSite() { 
1276 		TN retVal = this.getTypedField(29, 0);
1277 		return retVal;
1278     }
1279 
1280 
1281 
1282     /**
1283      * Returns
1284      * OM1-30: "Confidentiality Code" - creates it if necessary
1285      */
1286     public ID getConfidentialityCode() { 
1287 		ID retVal = this.getTypedField(30, 0);
1288 		return retVal;
1289     }
1290     
1291     /**
1292      * Returns
1293      * OM1-30: "Confidentiality Code" - creates it if necessary
1294      */
1295     public ID getOm130_ConfidentialityCode() { 
1296 		ID retVal = this.getTypedField(30, 0);
1297 		return retVal;
1298     }
1299 
1300 
1301 
1302     /**
1303      * Returns
1304      * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary
1305      */
1306     public CE getObservationsRequiredToInterpretTheObservation() { 
1307 		CE retVal = this.getTypedField(31, 0);
1308 		return retVal;
1309     }
1310     
1311     /**
1312      * Returns
1313      * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary
1314      */
1315     public CE getOm131_ObservationsRequiredToInterpretTheObservation() { 
1316 		CE retVal = this.getTypedField(31, 0);
1317 		return retVal;
1318     }
1319 
1320 
1321 
1322     /**
1323      * Returns
1324      * OM1-32: "Interpretation of Observations" - creates it if necessary
1325      */
1326     public TX getInterpretationOfObservations() { 
1327 		TX retVal = this.getTypedField(32, 0);
1328 		return retVal;
1329     }
1330     
1331     /**
1332      * Returns
1333      * OM1-32: "Interpretation of Observations" - creates it if necessary
1334      */
1335     public TX getOm132_InterpretationOfObservations() { 
1336 		TX retVal = this.getTypedField(32, 0);
1337 		return retVal;
1338     }
1339 
1340 
1341 
1342     /**
1343      * Returns
1344      * OM1-33: "Contraindications to Observations" - creates it if necessary
1345      */
1346     public CE getContraindicationsToObservations() { 
1347 		CE retVal = this.getTypedField(33, 0);
1348 		return retVal;
1349     }
1350     
1351     /**
1352      * Returns
1353      * OM1-33: "Contraindications to Observations" - creates it if necessary
1354      */
1355     public CE getOm133_ContraindicationsToObservations() { 
1356 		CE retVal = this.getTypedField(33, 0);
1357 		return retVal;
1358     }
1359 
1360 
1361     /**
1362      * Returns all repetitions of Reflex Tests/Observations (OM1-34).
1363      */
1364     public CE[] getReflexTestsObservations() {
1365     	CE[] retVal = this.getTypedField(34, new CE[0]);
1366     	return retVal;
1367     }
1368 
1369 
1370     /**
1371      * Returns all repetitions of Reflex Tests/Observations (OM1-34).
1372      */
1373     public CE[] getOm134_ReflexTestsObservations() {
1374     	CE[] retVal = this.getTypedField(34, new CE[0]);
1375     	return retVal;
1376     }
1377 
1378 
1379     /**
1380      * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34).
1381      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1382      * it will return zero.
1383      */
1384     public int getReflexTestsObservationsReps() {
1385     	return this.getReps(34);
1386     }
1387 
1388 
1389     /**
1390      * Returns a specific repetition of
1391      * OM1-34: "Reflex Tests/Observations" - creates it if necessary
1392      *
1393      * @param rep The repetition index (0-indexed)
1394      */
1395     public CE getReflexTestsObservations(int rep) { 
1396 		CE retVal = this.getTypedField(34, rep);
1397 		return retVal;
1398     }
1399 
1400     /**
1401      * Returns a specific repetition of
1402      * OM1-34: "Reflex Tests/Observations" - creates it if necessary
1403      *
1404      * @param rep The repetition index (0-indexed)
1405      */
1406     public CE getOm134_ReflexTestsObservations(int rep) { 
1407 		CE retVal = this.getTypedField(34, rep);
1408 		return retVal;
1409     }
1410 
1411     /**
1412      * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34).
1413      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1414      * it will return zero.
1415      */
1416     public int getOm134_ReflexTestsObservationsReps() {
1417     	return this.getReps(34);
1418     }
1419 
1420 
1421     /**
1422      * Inserts a repetition of
1423      * OM1-34: "Reflex Tests/Observations" at a specific index
1424      *
1425      * @param rep The repetition index (0-indexed)
1426      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1427      */
1428     public CE insertReflexTestsObservations(int rep) throws HL7Exception { 
1429         return (CE) super.insertRepetition(34, rep);
1430     }
1431 
1432 
1433     /**
1434      * Inserts a repetition of
1435      * OM1-34: "Reflex Tests/Observations" at a specific index
1436      *
1437      * @param rep The repetition index (0-indexed)
1438      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1439      */
1440     public CE insertOm134_ReflexTestsObservations(int rep) throws HL7Exception { 
1441         return (CE) super.insertRepetition(34, rep);
1442     }
1443 
1444 
1445     /**
1446      * Removes a repetition of
1447      * OM1-34: "Reflex Tests/Observations" at a specific index
1448      *
1449      * @param rep The repetition index (0-indexed)
1450      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1451      */
1452     public CE removeReflexTestsObservations(int rep) throws HL7Exception { 
1453         return (CE) super.removeRepetition(34, rep);
1454     }
1455 
1456 
1457     /**
1458      * Removes a repetition of
1459      * OM1-34: "Reflex Tests/Observations" at a specific index
1460      *
1461      * @param rep The repetition index (0-indexed)
1462      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1463      */
1464     public CE removeOm134_ReflexTestsObservations(int rep) throws HL7Exception { 
1465         return (CE) super.removeRepetition(34, rep);
1466     }
1467 
1468 
1469 
1470 
1471     /**
1472      * Returns
1473      * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary
1474      */
1475     public ST getRulesThatTriggerReflexTesting() { 
1476 		ST retVal = this.getTypedField(35, 0);
1477 		return retVal;
1478     }
1479     
1480     /**
1481      * Returns
1482      * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary
1483      */
1484     public ST getOm135_RulesThatTriggerReflexTesting() { 
1485 		ST retVal = this.getTypedField(35, 0);
1486 		return retVal;
1487     }
1488 
1489 
1490 
1491     /**
1492      * Returns
1493      * OM1-36: "Fixed Canned Message" - creates it if necessary
1494      */
1495     public CE getFixedCannedMessage() { 
1496 		CE retVal = this.getTypedField(36, 0);
1497 		return retVal;
1498     }
1499     
1500     /**
1501      * Returns
1502      * OM1-36: "Fixed Canned Message" - creates it if necessary
1503      */
1504     public CE getOm136_FixedCannedMessage() { 
1505 		CE retVal = this.getTypedField(36, 0);
1506 		return retVal;
1507     }
1508 
1509 
1510 
1511     /**
1512      * Returns
1513      * OM1-37: "Patient Preparation" - creates it if necessary
1514      */
1515     public TX getPatientPreparation() { 
1516 		TX retVal = this.getTypedField(37, 0);
1517 		return retVal;
1518     }
1519     
1520     /**
1521      * Returns
1522      * OM1-37: "Patient Preparation" - creates it if necessary
1523      */
1524     public TX getOm137_PatientPreparation() { 
1525 		TX retVal = this.getTypedField(37, 0);
1526 		return retVal;
1527     }
1528 
1529 
1530 
1531     /**
1532      * Returns
1533      * OM1-38: "Procedure Medication" - creates it if necessary
1534      */
1535     public CE getProcedureMedication() { 
1536 		CE retVal = this.getTypedField(38, 0);
1537 		return retVal;
1538     }
1539     
1540     /**
1541      * Returns
1542      * OM1-38: "Procedure Medication" - creates it if necessary
1543      */
1544     public CE getOm138_ProcedureMedication() { 
1545 		CE retVal = this.getTypedField(38, 0);
1546 		return retVal;
1547     }
1548 
1549 
1550 
1551     /**
1552      * Returns
1553      * OM1-39: "Factors that may Effect the Observation" - creates it if necessary
1554      */
1555     public TX getFactorsThatMayEffectTheObservation() { 
1556 		TX retVal = this.getTypedField(39, 0);
1557 		return retVal;
1558     }
1559     
1560     /**
1561      * Returns
1562      * OM1-39: "Factors that may Effect the Observation" - creates it if necessary
1563      */
1564     public TX getOm139_FactorsThatMayEffectTheObservation() { 
1565 		TX retVal = this.getTypedField(39, 0);
1566 		return retVal;
1567     }
1568 
1569 
1570     /**
1571      * Returns all repetitions of Test/Observation Performance Schedule (OM1-40).
1572      */
1573     public ST[] getTestObservationPerformanceSchedule() {
1574     	ST[] retVal = this.getTypedField(40, new ST[0]);
1575     	return retVal;
1576     }
1577 
1578 
1579     /**
1580      * Returns all repetitions of Test/Observation Performance Schedule (OM1-40).
1581      */
1582     public ST[] getOm140_TestObservationPerformanceSchedule() {
1583     	ST[] retVal = this.getTypedField(40, new ST[0]);
1584     	return retVal;
1585     }
1586 
1587 
1588     /**
1589      * Returns a count of the current number of repetitions of Test/Observation Performance Schedule (OM1-40).
1590      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1591      * it will return zero.
1592      */
1593     public int getTestObservationPerformanceScheduleReps() {
1594     	return this.getReps(40);
1595     }
1596 
1597 
1598     /**
1599      * Returns a specific repetition of
1600      * OM1-40: "Test/Observation Performance Schedule" - creates it if necessary
1601      *
1602      * @param rep The repetition index (0-indexed)
1603      */
1604     public ST getTestObservationPerformanceSchedule(int rep) { 
1605 		ST retVal = this.getTypedField(40, rep);
1606 		return retVal;
1607     }
1608 
1609     /**
1610      * Returns a specific repetition of
1611      * OM1-40: "Test/Observation Performance Schedule" - creates it if necessary
1612      *
1613      * @param rep The repetition index (0-indexed)
1614      */
1615     public ST getOm140_TestObservationPerformanceSchedule(int rep) { 
1616 		ST retVal = this.getTypedField(40, rep);
1617 		return retVal;
1618     }
1619 
1620     /**
1621      * Returns a count of the current number of repetitions of Test/Observation Performance Schedule (OM1-40).
1622      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1623      * it will return zero.
1624      */
1625     public int getOm140_TestObservationPerformanceScheduleReps() {
1626     	return this.getReps(40);
1627     }
1628 
1629 
1630     /**
1631      * Inserts a repetition of
1632      * OM1-40: "Test/Observation Performance Schedule" at a specific index
1633      *
1634      * @param rep The repetition index (0-indexed)
1635      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1636      */
1637     public ST insertTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
1638         return (ST) super.insertRepetition(40, rep);
1639     }
1640 
1641 
1642     /**
1643      * Inserts a repetition of
1644      * OM1-40: "Test/Observation Performance Schedule" at a specific index
1645      *
1646      * @param rep The repetition index (0-indexed)
1647      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1648      */
1649     public ST insertOm140_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 
1650         return (ST) super.insertRepetition(40, rep);
1651     }
1652 
1653 
1654     /**
1655      * Removes a repetition of
1656      * OM1-40: "Test/Observation Performance Schedule" at a specific index
1657      *
1658      * @param rep The repetition index (0-indexed)
1659      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1660      */
1661     public ST removeTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
1662         return (ST) super.removeRepetition(40, rep);
1663     }
1664 
1665 
1666     /**
1667      * Removes a repetition of
1668      * OM1-40: "Test/Observation Performance Schedule" at a specific index
1669      *
1670      * @param rep The repetition index (0-indexed)
1671      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1672      */
1673     public ST removeOm140_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 
1674         return (ST) super.removeRepetition(40, rep);
1675     }
1676 
1677 
1678 
1679 
1680     /**
1681      * Returns
1682      * OM1-41: "Description of Test Methods" - creates it if necessary
1683      */
1684     public TX getDescriptionOfTestMethods() { 
1685 		TX retVal = this.getTypedField(41, 0);
1686 		return retVal;
1687     }
1688     
1689     /**
1690      * Returns
1691      * OM1-41: "Description of Test Methods" - creates it if necessary
1692      */
1693     public TX getOm141_DescriptionOfTestMethods() { 
1694 		TX retVal = this.getTypedField(41, 0);
1695 		return retVal;
1696     }
1697 
1698 
1699 
1700     /**
1701      * Returns
1702      * OM1-42: "Kind of Quantity Observed" - creates it if necessary
1703      */
1704     public CE getKindOfQuantityObserved() { 
1705 		CE retVal = this.getTypedField(42, 0);
1706 		return retVal;
1707     }
1708     
1709     /**
1710      * Returns
1711      * OM1-42: "Kind of Quantity Observed" - creates it if necessary
1712      */
1713     public CE getOm142_KindOfQuantityObserved() { 
1714 		CE retVal = this.getTypedField(42, 0);
1715 		return retVal;
1716     }
1717 
1718 
1719 
1720     /**
1721      * Returns
1722      * OM1-43: "Point versus Interval" - creates it if necessary
1723      */
1724     public CE getPointVersusInterval() { 
1725 		CE retVal = this.getTypedField(43, 0);
1726 		return retVal;
1727     }
1728     
1729     /**
1730      * Returns
1731      * OM1-43: "Point versus Interval" - creates it if necessary
1732      */
1733     public CE getOm143_PointVersusInterval() { 
1734 		CE retVal = this.getTypedField(43, 0);
1735 		return retVal;
1736     }
1737 
1738 
1739 
1740     /**
1741      * Returns
1742      * OM1-44: "Challenge information" - creates it if necessary
1743      */
1744     public TX getChallengeInformation() { 
1745 		TX retVal = this.getTypedField(44, 0);
1746 		return retVal;
1747     }
1748     
1749     /**
1750      * Returns
1751      * OM1-44: "Challenge information" - creates it if necessary
1752      */
1753     public TX getOm144_ChallengeInformation() { 
1754 		TX retVal = this.getTypedField(44, 0);
1755 		return retVal;
1756     }
1757 
1758 
1759 
1760     /**
1761      * Returns
1762      * OM1-45: "Relationship modifier" - creates it if necessary
1763      */
1764     public CE getRelationshipModifier() { 
1765 		CE retVal = this.getTypedField(45, 0);
1766 		return retVal;
1767     }
1768     
1769     /**
1770      * Returns
1771      * OM1-45: "Relationship modifier" - creates it if necessary
1772      */
1773     public CE getOm145_RelationshipModifier() { 
1774 		CE retVal = this.getTypedField(45, 0);
1775 		return retVal;
1776     }
1777 
1778 
1779 
1780     /**
1781      * Returns
1782      * OM1-46: "Target anatomic site of test" - creates it if necessary
1783      */
1784     public CE getTargetAnatomicSiteOfTest() { 
1785 		CE retVal = this.getTypedField(46, 0);
1786 		return retVal;
1787     }
1788     
1789     /**
1790      * Returns
1791      * OM1-46: "Target anatomic site of test" - creates it if necessary
1792      */
1793     public CE getOm146_TargetAnatomicSiteOfTest() { 
1794 		CE retVal = this.getTypedField(46, 0);
1795 		return retVal;
1796     }
1797 
1798 
1799 
1800     /**
1801      * Returns
1802      * OM1-47: "Modality of imaging measurement" - creates it if necessary
1803      */
1804     public CE getModalityOfImagingMeasurement() { 
1805 		CE retVal = this.getTypedField(47, 0);
1806 		return retVal;
1807     }
1808     
1809     /**
1810      * Returns
1811      * OM1-47: "Modality of imaging measurement" - creates it if necessary
1812      */
1813     public CE getOm147_ModalityOfImagingMeasurement() { 
1814 		CE retVal = this.getTypedField(47, 0);
1815 		return retVal;
1816     }
1817 
1818 
1819 
1820 
1821 
1822     /** {@inheritDoc} */   
1823     protected Type createNewTypeWithoutReflection(int field) {
1824        switch (field) {
1825           case 0: return new NM(getMessage());
1826           case 1: return new CE(getMessage());
1827           case 2: return new ID(getMessage(), new Integer( 125 ));
1828           case 3: return new ID(getMessage(), new Integer( 136 ));
1829           case 4: return new CE(getMessage());
1830           case 5: return new CE(getMessage());
1831           case 6: return new CE(getMessage());
1832           case 7: return new ST(getMessage());
1833           case 8: return new ST(getMessage());
1834           case 9: return new ST(getMessage());
1835           case 10: return new ST(getMessage());
1836           case 11: return new ID(getMessage(), new Integer( 136 ));
1837           case 12: return new CE(getMessage());
1838           case 13: return new CE(getMessage());
1839           case 14: return new ID(getMessage(), new Integer( 136 ));
1840           case 15: return new CE(getMessage());
1841           case 16: return new TN(getMessage());
1842           case 17: return new ID(getMessage(), new Integer( 174 ));
1843           case 18: return new CE(getMessage());
1844           case 19: return new ST(getMessage());
1845           case 20: return new TS(getMessage());
1846           case 21: return new TS(getMessage());
1847           case 22: return new NM(getMessage());
1848           case 23: return new NM(getMessage());
1849           case 24: return new ID(getMessage(), new Integer( 168 ));
1850           case 25: return new ID(getMessage(), new Integer( 169 ));
1851           case 26: return new CE(getMessage());
1852           case 27: return new AD(getMessage());
1853           case 28: return new TN(getMessage());
1854           case 29: return new ID(getMessage(), new Integer( 177 ));
1855           case 30: return new CE(getMessage());
1856           case 31: return new TX(getMessage());
1857           case 32: return new CE(getMessage());
1858           case 33: return new CE(getMessage());
1859           case 34: return new ST(getMessage());
1860           case 35: return new CE(getMessage());
1861           case 36: return new TX(getMessage());
1862           case 37: return new CE(getMessage());
1863           case 38: return new TX(getMessage());
1864           case 39: return new ST(getMessage());
1865           case 40: return new TX(getMessage());
1866           case 41: return new CE(getMessage());
1867           case 42: return new CE(getMessage());
1868           case 43: return new TX(getMessage());
1869           case 44: return new CE(getMessage());
1870           case 45: return new CE(getMessage());
1871           case 46: return new CE(getMessage());
1872           default: return null;
1873        }
1874    }
1875 
1876 
1877 }
1878