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.v281.segment;
35  
36  // import ca.uhn.hl7v2.model.v281.group.*;
37  import ca.uhn.hl7v2.model.v281.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 Segment). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>OM1-1: Sequence Number - Test/Observation Master File (NM) <b> </b>
53       * <li>OM1-2: Producer's Service/Test/Observation ID (CWE) <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 (CWE) <b> </b>
57       * <li>OM1-6: Observation Description (TX) <b>optional </b>
58       * <li>OM1-7: Other Service/Test/Observation IDs for the Observation (CWE) <b>optional repeating</b>
59       * <li>OM1-8: Other Names (ST) <b>optional 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 the 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 Perform this Study (CWE) <b>optional repeating</b>
65       * <li>OM1-14: Coded Representation of Method (CWE) <b>optional repeating</b>
66       * <li>OM1-15: Portable Device Indicator (ID) <b>optional </b>
67       * <li>OM1-16: Observation Producing Department/Section (CWE) <b>optional repeating</b>
68       * <li>OM1-17: Telephone Number of Section (XTN) <b>optional </b>
69       * <li>OM1-18: Nature of Service/Test/Observation (CWE) <b> </b>
70       * <li>OM1-19: Report Subheader (CWE) <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 Definition for the Observation (DTM) <b>optional </b>
73       * <li>OM1-22: Effective Date/Time of Change (DTM) <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 (CWE) <b>optional repeating</b>
79       * <li>OM1-28: Address of Outside Site(s) (XAD) <b>optional repeating</b>
80       * <li>OM1-29: Phone Number of Outside Site (XTN) <b>optional </b>
81       * <li>OM1-30: Confidentiality Code (CWE) <b>optional </b>
82       * <li>OM1-31: Observations Required to Interpret this Observation (CWE) <b>optional repeating</b>
83       * <li>OM1-32: Interpretation of Observations (TX) <b>optional </b>
84       * <li>OM1-33: Contraindications to Observations (CWE) <b>optional repeating</b>
85       * <li>OM1-34: Reflex Tests/Observations (CWE) <b>optional repeating</b>
86       * <li>OM1-35: Rules that Trigger Reflex Testing (TX) <b>optional repeating</b>
87       * <li>OM1-36: Fixed Canned Message (CWE) <b>optional repeating</b>
88       * <li>OM1-37: Patient Preparation (TX) <b>optional repeating</b>
89       * <li>OM1-38: Procedure Medication (CWE) <b>optional </b>
90       * <li>OM1-39: Factors that may Affect the Observation (TX) <b>optional </b>
91       * <li>OM1-40: Service/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 (CWE) <b>optional </b>
94       * <li>OM1-43: Point Versus Interval (CWE) <b>optional </b>
95       * <li>OM1-44: Challenge Information (TX) <b>optional </b>
96       * <li>OM1-45: Relationship Modifier (CWE) <b>optional </b>
97       * <li>OM1-46: Target Anatomic Site Of Test (CWE) <b>optional </b>
98       * <li>OM1-47: Modality of Imaging Measurement (CWE) <b>optional </b>
99       * <li>OM1-48: Exclusive Test (ID) <b>optional </b>
100      * <li>OM1-49: Diagnostic Serv Sect ID (ID) <b>optional </b>
101      * <li>OM1-50: Taxonomic Classification Code (CWE) <b>optional </b>
102      * <li>OM1-51: Other Names Number 2 (ST) <b>optional repeating</b>
103      * <li>OM1-52: Replacement Producer's Service/Test/Observation ID (CWE) <b>optional repeating</b>
104      * <li>OM1-53: Prior Resuts Instructions (TX) <b>optional repeating</b>
105      * <li>OM1-54: Special Instructions (TX) <b>optional </b>
106      * <li>OM1-55: Test Category (CWE) <b>optional repeating</b>
107  * </ul>
108  */
109 @SuppressWarnings("unused")
110 public class OM1 extends AbstractSegment {
111 
112     /** 
113      * Creates a new OM1 segment
114      */
115     public OM1(Group parent, ModelClassFactory factory) {
116        super(parent, factory);
117        init(factory);
118     }
119 
120     private void init(ModelClassFactory factory) {
121        try {
122                                   this.add(NM.class, true, 1, 0, new Object[]{ getMessage() }, "Sequence Number - Test/Observation Master File");
123                                   this.add(CWE.class, true, 1, 0, new Object[]{ getMessage() }, "Producer's Service/Test/Observation ID");
124                                               this.add(ID.class, false, 0, 0, new Object[]{ getMessage(), new Integer(125) }, "Permitted Data Types");
125                                               this.add(ID.class, true, 1, 0, new Object[]{ getMessage(), new Integer(136) }, "Specimen Required");
126                                   this.add(CWE.class, true, 1, 0, new Object[]{ getMessage() }, "Producer ID");
127                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Observation Description");
128                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Other Service/Test/Observation IDs for the Observation");
129                                   this.add(ST.class, false, 0, 0, new Object[]{ getMessage() }, "Other Names");
130                                   this.add(ST.class, false, 1, 0, new Object[]{ getMessage() }, "Preferred Report Name for the Observation");
131                                   this.add(ST.class, false, 1, 0, new Object[]{ getMessage() }, "Preferred Short Name or Mnemonic for the Observation");
132                                   this.add(ST.class, false, 1, 0, new Object[]{ getMessage() }, "Preferred Long Name for the Observation");
133                                               this.add(ID.class, false, 1, 0, new Object[]{ getMessage(), new Integer(136) }, "Orderability");
134                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Identity of Instrument Used to Perform this Study");
135                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Coded Representation of Method");
136                                               this.add(ID.class, false, 1, 0, new Object[]{ getMessage(), new Integer(136) }, "Portable Device Indicator");
137                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Observation Producing Department/Section");
138                                   this.add(XTN.class, false, 1, 0, new Object[]{ getMessage() }, "Telephone Number of Section");
139                                   this.add(CWE.class, true, 1, 0, new Object[]{ getMessage() }, "Nature of Service/Test/Observation");
140                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Report Subheader");
141                                   this.add(ST.class, false, 1, 0, new Object[]{ getMessage() }, "Report Display Order");
142                                   this.add(DTM.class, false, 1, 0, new Object[]{ getMessage() }, "Date/Time Stamp for Any Change in Definition for the Observation");
143                                   this.add(DTM.class, false, 1, 0, new Object[]{ getMessage() }, "Effective Date/Time of Change");
144                                   this.add(NM.class, false, 1, 0, new Object[]{ getMessage() }, "Typical Turn-Around Time");
145                                   this.add(NM.class, false, 1, 0, new Object[]{ getMessage() }, "Processing Time");
146                                               this.add(ID.class, false, 0, 0, new Object[]{ getMessage(), new Integer(168) }, "Processing Priority");
147                                               this.add(ID.class, false, 1, 0, new Object[]{ getMessage(), new Integer(169) }, "Reporting Priority");
148                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Outside Site(s) Where Observation May Be Performed");
149                                   this.add(XAD.class, false, 0, 0, new Object[]{ getMessage() }, "Address of Outside Site(s)");
150                                   this.add(XTN.class, false, 1, 0, new Object[]{ getMessage() }, "Phone Number of Outside Site");
151                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Confidentiality Code");
152                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Observations Required to Interpret this Observation");
153                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Interpretation of Observations");
154                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Contraindications to Observations");
155                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Reflex Tests/Observations");
156                                   this.add(TX.class, false, 0, 0, new Object[]{ getMessage() }, "Rules that Trigger Reflex Testing");
157                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Fixed Canned Message");
158                                   this.add(TX.class, false, 0, 0, new Object[]{ getMessage() }, "Patient Preparation");
159                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Procedure Medication");
160                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Factors that may Affect the Observation");
161                                   this.add(ST.class, false, 0, 0, new Object[]{ getMessage() }, "Service/Test/Observation Performance Schedule");
162                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Description of Test Methods");
163                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Kind of Quantity Observed");
164                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Point Versus Interval");
165                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Challenge Information");
166                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Relationship Modifier");
167                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Target Anatomic Site Of Test");
168                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Modality of Imaging Measurement");
169                                               this.add(ID.class, false, 1, 0, new Object[]{ getMessage(), new Integer(919) }, "Exclusive Test");
170                                               this.add(ID.class, false, 1, 0, new Object[]{ getMessage(), new Integer(74) }, "Diagnostic Serv Sect ID");
171                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Taxonomic Classification Code");
172                                   this.add(ST.class, false, 0, 0, new Object[]{ getMessage() }, "Other Names Number 2");
173                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Replacement Producer's Service/Test/Observation ID");
174                                   this.add(TX.class, false, 0, 0, new Object[]{ getMessage() }, "Prior Resuts Instructions");
175                                   this.add(TX.class, false, 1, 0, new Object[]{ getMessage() }, "Special Instructions");
176                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Test Category");
177        } catch(HL7Exception e) {
178           log.error("Unexpected error creating OM1 - this is probably a bug in the source code generator.", e);
179        }
180     }
181 
182 
183 
184     /**
185      * Returns
186      * OM1-1: "Sequence Number - Test/Observation Master File" - creates it if necessary
187      */
188     public NM getSequenceNumberTestObservationMasterFile() { 
189 		NM retVal = this.getTypedField(1, 0);
190 		return retVal;
191     }
192     
193     /**
194      * Returns
195      * OM1-1: "Sequence Number - Test/Observation Master File" - creates it if necessary
196      */
197     public NM getOm11_SequenceNumberTestObservationMasterFile() { 
198 		NM retVal = this.getTypedField(1, 0);
199 		return retVal;
200     }
201 
202 
203 
204     /**
205      * Returns
206      * OM1-2: "Producer's Service/Test/Observation ID" - creates it if necessary
207      */
208     public CWE getProducerSServiceTestObservationID() { 
209 		CWE retVal = this.getTypedField(2, 0);
210 		return retVal;
211     }
212     
213     /**
214      * Returns
215      * OM1-2: "Producer's Service/Test/Observation ID" - creates it if necessary
216      */
217     public CWE getOm12_ProducerSServiceTestObservationID() { 
218 		CWE retVal = this.getTypedField(2, 0);
219 		return retVal;
220     }
221 
222 
223     /**
224      * Returns all repetitions of Permitted Data Types (OM1-3).
225      */
226     public ID[] getPermittedDataTypes() {
227     	ID[] retVal = this.getTypedField(3, new ID[0]);
228     	return retVal;
229     }
230 
231 
232     /**
233      * Returns all repetitions of Permitted Data Types (OM1-3).
234      */
235     public ID[] getOm13_PermittedDataTypes() {
236     	ID[] retVal = this.getTypedField(3, new ID[0]);
237     	return retVal;
238     }
239 
240 
241     /**
242      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3).
243      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
244      * it will return zero.
245      */
246     public int getPermittedDataTypesReps() {
247     	return this.getReps(3);
248     }
249 
250 
251     /**
252      * Returns a specific repetition of
253      * OM1-3: "Permitted Data Types" - creates it if necessary
254      *
255      * @param rep The repetition index (0-indexed)
256      */
257     public ID getPermittedDataTypes(int rep) { 
258 		ID retVal = this.getTypedField(3, rep);
259 		return retVal;
260     }
261 
262     /**
263      * Returns a specific repetition of
264      * OM1-3: "Permitted Data Types" - creates it if necessary
265      *
266      * @param rep The repetition index (0-indexed)
267      */
268     public ID getOm13_PermittedDataTypes(int rep) { 
269 		ID retVal = this.getTypedField(3, rep);
270 		return retVal;
271     }
272 
273     /**
274      * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3).
275      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
276      * it will return zero.
277      */
278     public int getOm13_PermittedDataTypesReps() {
279     	return this.getReps(3);
280     }
281 
282 
283     /**
284      * Inserts a repetition of
285      * OM1-3: "Permitted Data Types" at a specific index
286      *
287      * @param rep The repetition index (0-indexed)
288      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
289      */
290     public ID insertPermittedDataTypes(int rep) throws HL7Exception { 
291         return (ID) super.insertRepetition(3, rep);
292     }
293 
294 
295     /**
296      * Inserts a repetition of
297      * OM1-3: "Permitted Data Types" at a specific index
298      *
299      * @param rep The repetition index (0-indexed)
300      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
301      */
302     public ID insertOm13_PermittedDataTypes(int rep) throws HL7Exception { 
303         return (ID) super.insertRepetition(3, rep);
304     }
305 
306 
307     /**
308      * Removes a repetition of
309      * OM1-3: "Permitted Data Types" at a specific index
310      *
311      * @param rep The repetition index (0-indexed)
312      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
313      */
314     public ID removePermittedDataTypes(int rep) throws HL7Exception { 
315         return (ID) super.removeRepetition(3, rep);
316     }
317 
318 
319     /**
320      * Removes a repetition of
321      * OM1-3: "Permitted Data Types" at a specific index
322      *
323      * @param rep The repetition index (0-indexed)
324      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
325      */
326     public ID removeOm13_PermittedDataTypes(int rep) throws HL7Exception { 
327         return (ID) super.removeRepetition(3, rep);
328     }
329 
330 
331 
332 
333     /**
334      * Returns
335      * OM1-4: "Specimen Required" - creates it if necessary
336      */
337     public ID getSpecimenRequired() { 
338 		ID retVal = this.getTypedField(4, 0);
339 		return retVal;
340     }
341     
342     /**
343      * Returns
344      * OM1-4: "Specimen Required" - creates it if necessary
345      */
346     public ID getOm14_SpecimenRequired() { 
347 		ID retVal = this.getTypedField(4, 0);
348 		return retVal;
349     }
350 
351 
352 
353     /**
354      * Returns
355      * OM1-5: "Producer ID" - creates it if necessary
356      */
357     public CWE getProducerID() { 
358 		CWE retVal = this.getTypedField(5, 0);
359 		return retVal;
360     }
361     
362     /**
363      * Returns
364      * OM1-5: "Producer ID" - creates it if necessary
365      */
366     public CWE getOm15_ProducerID() { 
367 		CWE retVal = this.getTypedField(5, 0);
368 		return retVal;
369     }
370 
371 
372 
373     /**
374      * Returns
375      * OM1-6: "Observation Description" - creates it if necessary
376      */
377     public TX getObservationDescription() { 
378 		TX retVal = this.getTypedField(6, 0);
379 		return retVal;
380     }
381     
382     /**
383      * Returns
384      * OM1-6: "Observation Description" - creates it if necessary
385      */
386     public TX getOm16_ObservationDescription() { 
387 		TX retVal = this.getTypedField(6, 0);
388 		return retVal;
389     }
390 
391 
392     /**
393      * Returns all repetitions of Other Service/Test/Observation IDs for the Observation (OM1-7).
394      */
395     public CWE[] getOtherServiceTestObservationIDsForTheObservation() {
396     	CWE[] retVal = this.getTypedField(7, new CWE[0]);
397     	return retVal;
398     }
399 
400 
401     /**
402      * Returns all repetitions of Other Service/Test/Observation IDs for the Observation (OM1-7).
403      */
404     public CWE[] getOm17_OtherServiceTestObservationIDsForTheObservation() {
405     	CWE[] retVal = this.getTypedField(7, new CWE[0]);
406     	return retVal;
407     }
408 
409 
410     /**
411      * Returns a count of the current number of repetitions of Other Service/Test/Observation IDs for the Observation (OM1-7).
412      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
413      * it will return zero.
414      */
415     public int getOtherServiceTestObservationIDsForTheObservationReps() {
416     	return this.getReps(7);
417     }
418 
419 
420     /**
421      * Returns a specific repetition of
422      * OM1-7: "Other Service/Test/Observation IDs for the Observation" - creates it if necessary
423      *
424      * @param rep The repetition index (0-indexed)
425      */
426     public CWE getOtherServiceTestObservationIDsForTheObservation(int rep) { 
427 		CWE retVal = this.getTypedField(7, rep);
428 		return retVal;
429     }
430 
431     /**
432      * Returns a specific repetition of
433      * OM1-7: "Other Service/Test/Observation IDs for the Observation" - creates it if necessary
434      *
435      * @param rep The repetition index (0-indexed)
436      */
437     public CWE getOm17_OtherServiceTestObservationIDsForTheObservation(int rep) { 
438 		CWE retVal = this.getTypedField(7, rep);
439 		return retVal;
440     }
441 
442     /**
443      * Returns a count of the current number of repetitions of Other Service/Test/Observation IDs for the Observation (OM1-7).
444      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
445      * it will return zero.
446      */
447     public int getOm17_OtherServiceTestObservationIDsForTheObservationReps() {
448     	return this.getReps(7);
449     }
450 
451 
452     /**
453      * Inserts a repetition of
454      * OM1-7: "Other Service/Test/Observation IDs for the Observation" at a specific index
455      *
456      * @param rep The repetition index (0-indexed)
457      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
458      */
459     public CWE insertOtherServiceTestObservationIDsForTheObservation(int rep) throws HL7Exception { 
460         return (CWE) super.insertRepetition(7, rep);
461     }
462 
463 
464     /**
465      * Inserts a repetition of
466      * OM1-7: "Other Service/Test/Observation IDs for the Observation" at a specific index
467      *
468      * @param rep The repetition index (0-indexed)
469      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
470      */
471     public CWE insertOm17_OtherServiceTestObservationIDsForTheObservation(int rep) throws HL7Exception { 
472         return (CWE) super.insertRepetition(7, rep);
473     }
474 
475 
476     /**
477      * Removes a repetition of
478      * OM1-7: "Other Service/Test/Observation IDs for the Observation" at a specific index
479      *
480      * @param rep The repetition index (0-indexed)
481      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
482      */
483     public CWE removeOtherServiceTestObservationIDsForTheObservation(int rep) throws HL7Exception { 
484         return (CWE) super.removeRepetition(7, rep);
485     }
486 
487 
488     /**
489      * Removes a repetition of
490      * OM1-7: "Other Service/Test/Observation IDs for the Observation" at a specific index
491      *
492      * @param rep The repetition index (0-indexed)
493      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
494      */
495     public CWE removeOm17_OtherServiceTestObservationIDsForTheObservation(int rep) throws HL7Exception { 
496         return (CWE) super.removeRepetition(7, rep);
497     }
498 
499 
500 
501     /**
502      * Returns all repetitions of Other Names (OM1-8).
503      */
504     public ST[] getOtherNames() {
505     	ST[] retVal = this.getTypedField(8, new ST[0]);
506     	return retVal;
507     }
508 
509 
510     /**
511      * Returns all repetitions of Other Names (OM1-8).
512      */
513     public ST[] getOm18_OtherNames() {
514     	ST[] retVal = this.getTypedField(8, new ST[0]);
515     	return retVal;
516     }
517 
518 
519     /**
520      * Returns a count of the current number of repetitions of Other Names (OM1-8).
521      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
522      * it will return zero.
523      */
524     public int getOtherNamesReps() {
525     	return this.getReps(8);
526     }
527 
528 
529     /**
530      * Returns a specific repetition of
531      * OM1-8: "Other Names" - creates it if necessary
532      *
533      * @param rep The repetition index (0-indexed)
534      */
535     public ST getOtherNames(int rep) { 
536 		ST retVal = this.getTypedField(8, rep);
537 		return retVal;
538     }
539 
540     /**
541      * Returns a specific repetition of
542      * OM1-8: "Other Names" - creates it if necessary
543      *
544      * @param rep The repetition index (0-indexed)
545      */
546     public ST getOm18_OtherNames(int rep) { 
547 		ST retVal = this.getTypedField(8, rep);
548 		return retVal;
549     }
550 
551     /**
552      * Returns a count of the current number of repetitions of Other Names (OM1-8).
553      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
554      * it will return zero.
555      */
556     public int getOm18_OtherNamesReps() {
557     	return this.getReps(8);
558     }
559 
560 
561     /**
562      * Inserts a repetition of
563      * OM1-8: "Other Names" at a specific index
564      *
565      * @param rep The repetition index (0-indexed)
566      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
567      */
568     public ST insertOtherNames(int rep) throws HL7Exception { 
569         return (ST) super.insertRepetition(8, rep);
570     }
571 
572 
573     /**
574      * Inserts a repetition of
575      * OM1-8: "Other Names" at a specific index
576      *
577      * @param rep The repetition index (0-indexed)
578      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
579      */
580     public ST insertOm18_OtherNames(int rep) throws HL7Exception { 
581         return (ST) super.insertRepetition(8, rep);
582     }
583 
584 
585     /**
586      * Removes a repetition of
587      * OM1-8: "Other Names" at a specific index
588      *
589      * @param rep The repetition index (0-indexed)
590      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
591      */
592     public ST removeOtherNames(int rep) throws HL7Exception { 
593         return (ST) super.removeRepetition(8, rep);
594     }
595 
596 
597     /**
598      * Removes a repetition of
599      * OM1-8: "Other Names" at a specific index
600      *
601      * @param rep The repetition index (0-indexed)
602      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
603      */
604     public ST removeOm18_OtherNames(int rep) throws HL7Exception { 
605         return (ST) super.removeRepetition(8, rep);
606     }
607 
608 
609 
610 
611     /**
612      * Returns
613      * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary
614      */
615     public ST getPreferredReportNameForTheObservation() { 
616 		ST retVal = this.getTypedField(9, 0);
617 		return retVal;
618     }
619     
620     /**
621      * Returns
622      * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary
623      */
624     public ST getOm19_PreferredReportNameForTheObservation() { 
625 		ST retVal = this.getTypedField(9, 0);
626 		return retVal;
627     }
628 
629 
630 
631     /**
632      * Returns
633      * OM1-10: "Preferred Short Name or Mnemonic for the Observation" - creates it if necessary
634      */
635     public ST getPreferredShortNameOrMnemonicForTheObservation() { 
636 		ST retVal = this.getTypedField(10, 0);
637 		return retVal;
638     }
639     
640     /**
641      * Returns
642      * OM1-10: "Preferred Short Name or Mnemonic for the Observation" - creates it if necessary
643      */
644     public ST getOm110_PreferredShortNameOrMnemonicForTheObservation() { 
645 		ST retVal = this.getTypedField(10, 0);
646 		return retVal;
647     }
648 
649 
650 
651     /**
652      * Returns
653      * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary
654      */
655     public ST getPreferredLongNameForTheObservation() { 
656 		ST retVal = this.getTypedField(11, 0);
657 		return retVal;
658     }
659     
660     /**
661      * Returns
662      * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary
663      */
664     public ST getOm111_PreferredLongNameForTheObservation() { 
665 		ST retVal = this.getTypedField(11, 0);
666 		return retVal;
667     }
668 
669 
670 
671     /**
672      * Returns
673      * OM1-12: "Orderability" - creates it if necessary
674      */
675     public ID getOrderability() { 
676 		ID retVal = this.getTypedField(12, 0);
677 		return retVal;
678     }
679     
680     /**
681      * Returns
682      * OM1-12: "Orderability" - creates it if necessary
683      */
684     public ID getOm112_Orderability() { 
685 		ID retVal = this.getTypedField(12, 0);
686 		return retVal;
687     }
688 
689 
690     /**
691      * Returns all repetitions of Identity of Instrument Used to Perform this Study (OM1-13).
692      */
693     public CWE[] getIdentityOfInstrumentUsedToPerformThisStudy() {
694     	CWE[] retVal = this.getTypedField(13, new CWE[0]);
695     	return retVal;
696     }
697 
698 
699     /**
700      * Returns all repetitions of Identity of Instrument Used to Perform this Study (OM1-13).
701      */
702     public CWE[] getOm113_IdentityOfInstrumentUsedToPerformThisStudy() {
703     	CWE[] retVal = this.getTypedField(13, new CWE[0]);
704     	return retVal;
705     }
706 
707 
708     /**
709      * Returns a count of the current number of repetitions of Identity of Instrument Used to Perform this Study (OM1-13).
710      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
711      * it will return zero.
712      */
713     public int getIdentityOfInstrumentUsedToPerformThisStudyReps() {
714     	return this.getReps(13);
715     }
716 
717 
718     /**
719      * Returns a specific repetition of
720      * OM1-13: "Identity of Instrument Used to Perform this Study" - creates it if necessary
721      *
722      * @param rep The repetition index (0-indexed)
723      */
724     public CWE getIdentityOfInstrumentUsedToPerformThisStudy(int rep) { 
725 		CWE retVal = this.getTypedField(13, rep);
726 		return retVal;
727     }
728 
729     /**
730      * Returns a specific repetition of
731      * OM1-13: "Identity of Instrument Used to Perform this Study" - creates it if necessary
732      *
733      * @param rep The repetition index (0-indexed)
734      */
735     public CWE getOm113_IdentityOfInstrumentUsedToPerformThisStudy(int rep) { 
736 		CWE retVal = this.getTypedField(13, rep);
737 		return retVal;
738     }
739 
740     /**
741      * Returns a count of the current number of repetitions of Identity of Instrument Used to Perform this Study (OM1-13).
742      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
743      * it will return zero.
744      */
745     public int getOm113_IdentityOfInstrumentUsedToPerformThisStudyReps() {
746     	return this.getReps(13);
747     }
748 
749 
750     /**
751      * Inserts a repetition of
752      * OM1-13: "Identity of Instrument Used to Perform this Study" at a specific index
753      *
754      * @param rep The repetition index (0-indexed)
755      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
756      */
757     public CWE insertIdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
758         return (CWE) super.insertRepetition(13, rep);
759     }
760 
761 
762     /**
763      * Inserts a repetition of
764      * OM1-13: "Identity of Instrument Used to Perform this Study" at a specific index
765      *
766      * @param rep The repetition index (0-indexed)
767      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
768      */
769     public CWE insertOm113_IdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
770         return (CWE) super.insertRepetition(13, rep);
771     }
772 
773 
774     /**
775      * Removes a repetition of
776      * OM1-13: "Identity of Instrument Used to Perform this Study" at a specific index
777      *
778      * @param rep The repetition index (0-indexed)
779      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
780      */
781     public CWE removeIdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
782         return (CWE) super.removeRepetition(13, rep);
783     }
784 
785 
786     /**
787      * Removes a repetition of
788      * OM1-13: "Identity of Instrument Used to Perform this Study" at a specific index
789      *
790      * @param rep The repetition index (0-indexed)
791      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
792      */
793     public CWE removeOm113_IdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 
794         return (CWE) super.removeRepetition(13, rep);
795     }
796 
797 
798 
799     /**
800      * Returns all repetitions of Coded Representation of Method (OM1-14).
801      */
802     public CWE[] getCodedRepresentationOfMethod() {
803     	CWE[] retVal = this.getTypedField(14, new CWE[0]);
804     	return retVal;
805     }
806 
807 
808     /**
809      * Returns all repetitions of Coded Representation of Method (OM1-14).
810      */
811     public CWE[] getOm114_CodedRepresentationOfMethod() {
812     	CWE[] retVal = this.getTypedField(14, new CWE[0]);
813     	return retVal;
814     }
815 
816 
817     /**
818      * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-14).
819      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
820      * it will return zero.
821      */
822     public int getCodedRepresentationOfMethodReps() {
823     	return this.getReps(14);
824     }
825 
826 
827     /**
828      * Returns a specific repetition of
829      * OM1-14: "Coded Representation of Method" - creates it if necessary
830      *
831      * @param rep The repetition index (0-indexed)
832      */
833     public CWE getCodedRepresentationOfMethod(int rep) { 
834 		CWE retVal = this.getTypedField(14, rep);
835 		return retVal;
836     }
837 
838     /**
839      * Returns a specific repetition of
840      * OM1-14: "Coded Representation of Method" - creates it if necessary
841      *
842      * @param rep The repetition index (0-indexed)
843      */
844     public CWE getOm114_CodedRepresentationOfMethod(int rep) { 
845 		CWE retVal = this.getTypedField(14, rep);
846 		return retVal;
847     }
848 
849     /**
850      * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-14).
851      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
852      * it will return zero.
853      */
854     public int getOm114_CodedRepresentationOfMethodReps() {
855     	return this.getReps(14);
856     }
857 
858 
859     /**
860      * Inserts a repetition of
861      * OM1-14: "Coded Representation of Method" at a specific index
862      *
863      * @param rep The repetition index (0-indexed)
864      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
865      */
866     public CWE insertCodedRepresentationOfMethod(int rep) throws HL7Exception { 
867         return (CWE) super.insertRepetition(14, rep);
868     }
869 
870 
871     /**
872      * Inserts a repetition of
873      * OM1-14: "Coded Representation of Method" at a specific index
874      *
875      * @param rep The repetition index (0-indexed)
876      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
877      */
878     public CWE insertOm114_CodedRepresentationOfMethod(int rep) throws HL7Exception { 
879         return (CWE) super.insertRepetition(14, rep);
880     }
881 
882 
883     /**
884      * Removes a repetition of
885      * OM1-14: "Coded Representation of Method" at a specific index
886      *
887      * @param rep The repetition index (0-indexed)
888      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
889      */
890     public CWE removeCodedRepresentationOfMethod(int rep) throws HL7Exception { 
891         return (CWE) super.removeRepetition(14, rep);
892     }
893 
894 
895     /**
896      * Removes a repetition of
897      * OM1-14: "Coded Representation of Method" at a specific index
898      *
899      * @param rep The repetition index (0-indexed)
900      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
901      */
902     public CWE removeOm114_CodedRepresentationOfMethod(int rep) throws HL7Exception { 
903         return (CWE) super.removeRepetition(14, rep);
904     }
905 
906 
907 
908 
909     /**
910      * Returns
911      * OM1-15: "Portable Device Indicator" - creates it if necessary
912      */
913     public ID getPortableDeviceIndicator() { 
914 		ID retVal = this.getTypedField(15, 0);
915 		return retVal;
916     }
917     
918     /**
919      * Returns
920      * OM1-15: "Portable Device Indicator" - creates it if necessary
921      */
922     public ID getOm115_PortableDeviceIndicator() { 
923 		ID retVal = this.getTypedField(15, 0);
924 		return retVal;
925     }
926 
927 
928     /**
929      * Returns all repetitions of Observation Producing Department/Section (OM1-16).
930      */
931     public CWE[] getObservationProducingDepartmentSection() {
932     	CWE[] retVal = this.getTypedField(16, new CWE[0]);
933     	return retVal;
934     }
935 
936 
937     /**
938      * Returns all repetitions of Observation Producing Department/Section (OM1-16).
939      */
940     public CWE[] getOm116_ObservationProducingDepartmentSection() {
941     	CWE[] retVal = this.getTypedField(16, new CWE[0]);
942     	return retVal;
943     }
944 
945 
946     /**
947      * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16).
948      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
949      * it will return zero.
950      */
951     public int getObservationProducingDepartmentSectionReps() {
952     	return this.getReps(16);
953     }
954 
955 
956     /**
957      * Returns a specific repetition of
958      * OM1-16: "Observation Producing Department/Section" - creates it if necessary
959      *
960      * @param rep The repetition index (0-indexed)
961      */
962     public CWE getObservationProducingDepartmentSection(int rep) { 
963 		CWE retVal = this.getTypedField(16, rep);
964 		return retVal;
965     }
966 
967     /**
968      * Returns a specific repetition of
969      * OM1-16: "Observation Producing Department/Section" - creates it if necessary
970      *
971      * @param rep The repetition index (0-indexed)
972      */
973     public CWE getOm116_ObservationProducingDepartmentSection(int rep) { 
974 		CWE retVal = this.getTypedField(16, rep);
975 		return retVal;
976     }
977 
978     /**
979      * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16).
980      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
981      * it will return zero.
982      */
983     public int getOm116_ObservationProducingDepartmentSectionReps() {
984     	return this.getReps(16);
985     }
986 
987 
988     /**
989      * Inserts a repetition of
990      * OM1-16: "Observation Producing Department/Section" at a specific index
991      *
992      * @param rep The repetition index (0-indexed)
993      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
994      */
995     public CWE insertObservationProducingDepartmentSection(int rep) throws HL7Exception { 
996         return (CWE) super.insertRepetition(16, rep);
997     }
998 
999 
1000     /**
1001      * Inserts a repetition of
1002      * OM1-16: "Observation Producing Department/Section" at a specific index
1003      *
1004      * @param rep The repetition index (0-indexed)
1005      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1006      */
1007     public CWE insertOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
1008         return (CWE) super.insertRepetition(16, rep);
1009     }
1010 
1011 
1012     /**
1013      * Removes a repetition of
1014      * OM1-16: "Observation Producing Department/Section" at a specific index
1015      *
1016      * @param rep The repetition index (0-indexed)
1017      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1018      */
1019     public CWE removeObservationProducingDepartmentSection(int rep) throws HL7Exception { 
1020         return (CWE) super.removeRepetition(16, rep);
1021     }
1022 
1023 
1024     /**
1025      * Removes a repetition of
1026      * OM1-16: "Observation Producing Department/Section" at a specific index
1027      *
1028      * @param rep The repetition index (0-indexed)
1029      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1030      */
1031     public CWE removeOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 
1032         return (CWE) super.removeRepetition(16, rep);
1033     }
1034 
1035 
1036 
1037 
1038     /**
1039      * Returns
1040      * OM1-17: "Telephone Number of Section" - creates it if necessary
1041      */
1042     public XTN getTelephoneNumberOfSection() { 
1043 		XTN retVal = this.getTypedField(17, 0);
1044 		return retVal;
1045     }
1046     
1047     /**
1048      * Returns
1049      * OM1-17: "Telephone Number of Section" - creates it if necessary
1050      */
1051     public XTN getOm117_TelephoneNumberOfSection() { 
1052 		XTN retVal = this.getTypedField(17, 0);
1053 		return retVal;
1054     }
1055 
1056 
1057 
1058     /**
1059      * Returns
1060      * OM1-18: "Nature of Service/Test/Observation" - creates it if necessary
1061      */
1062     public CWE getNatureOfServiceTestObservation() { 
1063 		CWE retVal = this.getTypedField(18, 0);
1064 		return retVal;
1065     }
1066     
1067     /**
1068      * Returns
1069      * OM1-18: "Nature of Service/Test/Observation" - creates it if necessary
1070      */
1071     public CWE getOm118_NatureOfServiceTestObservation() { 
1072 		CWE retVal = this.getTypedField(18, 0);
1073 		return retVal;
1074     }
1075 
1076 
1077 
1078     /**
1079      * Returns
1080      * OM1-19: "Report Subheader" - creates it if necessary
1081      */
1082     public CWE getReportSubheader() { 
1083 		CWE retVal = this.getTypedField(19, 0);
1084 		return retVal;
1085     }
1086     
1087     /**
1088      * Returns
1089      * OM1-19: "Report Subheader" - creates it if necessary
1090      */
1091     public CWE getOm119_ReportSubheader() { 
1092 		CWE retVal = this.getTypedField(19, 0);
1093 		return retVal;
1094     }
1095 
1096 
1097 
1098     /**
1099      * Returns
1100      * OM1-20: "Report Display Order" - creates it if necessary
1101      */
1102     public ST getReportDisplayOrder() { 
1103 		ST retVal = this.getTypedField(20, 0);
1104 		return retVal;
1105     }
1106     
1107     /**
1108      * Returns
1109      * OM1-20: "Report Display Order" - creates it if necessary
1110      */
1111     public ST getOm120_ReportDisplayOrder() { 
1112 		ST retVal = this.getTypedField(20, 0);
1113 		return retVal;
1114     }
1115 
1116 
1117 
1118     /**
1119      * Returns
1120      * OM1-21: "Date/Time Stamp for Any Change in Definition for the Observation" - creates it if necessary
1121      */
1122     public DTM getDateTimeStampForAnyChangeInDefinitionForTheObservation() { 
1123 		DTM retVal = this.getTypedField(21, 0);
1124 		return retVal;
1125     }
1126     
1127     /**
1128      * Returns
1129      * OM1-21: "Date/Time Stamp for Any Change in Definition for the Observation" - creates it if necessary
1130      */
1131     public DTM getOm121_DateTimeStampForAnyChangeInDefinitionForTheObservation() { 
1132 		DTM retVal = this.getTypedField(21, 0);
1133 		return retVal;
1134     }
1135 
1136 
1137 
1138     /**
1139      * Returns
1140      * OM1-22: "Effective Date/Time of Change" - creates it if necessary
1141      */
1142     public DTM getEffectiveDateTimeOfChange() { 
1143 		DTM retVal = this.getTypedField(22, 0);
1144 		return retVal;
1145     }
1146     
1147     /**
1148      * Returns
1149      * OM1-22: "Effective Date/Time of Change" - creates it if necessary
1150      */
1151     public DTM getOm122_EffectiveDateTimeOfChange() { 
1152 		DTM retVal = this.getTypedField(22, 0);
1153 		return retVal;
1154     }
1155 
1156 
1157 
1158     /**
1159      * Returns
1160      * OM1-23: "Typical Turn-Around Time" - creates it if necessary
1161      */
1162     public NM getTypicalTurnAroundTime() { 
1163 		NM retVal = this.getTypedField(23, 0);
1164 		return retVal;
1165     }
1166     
1167     /**
1168      * Returns
1169      * OM1-23: "Typical Turn-Around Time" - creates it if necessary
1170      */
1171     public NM getOm123_TypicalTurnAroundTime() { 
1172 		NM retVal = this.getTypedField(23, 0);
1173 		return retVal;
1174     }
1175 
1176 
1177 
1178     /**
1179      * Returns
1180      * OM1-24: "Processing Time" - creates it if necessary
1181      */
1182     public NM getProcessingTime() { 
1183 		NM retVal = this.getTypedField(24, 0);
1184 		return retVal;
1185     }
1186     
1187     /**
1188      * Returns
1189      * OM1-24: "Processing Time" - creates it if necessary
1190      */
1191     public NM getOm124_ProcessingTime() { 
1192 		NM retVal = this.getTypedField(24, 0);
1193 		return retVal;
1194     }
1195 
1196 
1197     /**
1198      * Returns all repetitions of Processing Priority (OM1-25).
1199      */
1200     public ID[] getProcessingPriority() {
1201     	ID[] retVal = this.getTypedField(25, new ID[0]);
1202     	return retVal;
1203     }
1204 
1205 
1206     /**
1207      * Returns all repetitions of Processing Priority (OM1-25).
1208      */
1209     public ID[] getOm125_ProcessingPriority() {
1210     	ID[] retVal = this.getTypedField(25, new ID[0]);
1211     	return retVal;
1212     }
1213 
1214 
1215     /**
1216      * Returns a count of the current number of repetitions of Processing Priority (OM1-25).
1217      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1218      * it will return zero.
1219      */
1220     public int getProcessingPriorityReps() {
1221     	return this.getReps(25);
1222     }
1223 
1224 
1225     /**
1226      * Returns a specific repetition of
1227      * OM1-25: "Processing Priority" - creates it if necessary
1228      *
1229      * @param rep The repetition index (0-indexed)
1230      */
1231     public ID getProcessingPriority(int rep) { 
1232 		ID retVal = this.getTypedField(25, rep);
1233 		return retVal;
1234     }
1235 
1236     /**
1237      * Returns a specific repetition of
1238      * OM1-25: "Processing Priority" - creates it if necessary
1239      *
1240      * @param rep The repetition index (0-indexed)
1241      */
1242     public ID getOm125_ProcessingPriority(int rep) { 
1243 		ID retVal = this.getTypedField(25, rep);
1244 		return retVal;
1245     }
1246 
1247     /**
1248      * Returns a count of the current number of repetitions of Processing Priority (OM1-25).
1249      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1250      * it will return zero.
1251      */
1252     public int getOm125_ProcessingPriorityReps() {
1253     	return this.getReps(25);
1254     }
1255 
1256 
1257     /**
1258      * Inserts a repetition of
1259      * OM1-25: "Processing Priority" at a specific index
1260      *
1261      * @param rep The repetition index (0-indexed)
1262      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1263      */
1264     public ID insertProcessingPriority(int rep) throws HL7Exception { 
1265         return (ID) super.insertRepetition(25, rep);
1266     }
1267 
1268 
1269     /**
1270      * Inserts a repetition of
1271      * OM1-25: "Processing Priority" at a specific index
1272      *
1273      * @param rep The repetition index (0-indexed)
1274      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1275      */
1276     public ID insertOm125_ProcessingPriority(int rep) throws HL7Exception { 
1277         return (ID) super.insertRepetition(25, rep);
1278     }
1279 
1280 
1281     /**
1282      * Removes a repetition of
1283      * OM1-25: "Processing Priority" at a specific index
1284      *
1285      * @param rep The repetition index (0-indexed)
1286      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1287      */
1288     public ID removeProcessingPriority(int rep) throws HL7Exception { 
1289         return (ID) super.removeRepetition(25, rep);
1290     }
1291 
1292 
1293     /**
1294      * Removes a repetition of
1295      * OM1-25: "Processing Priority" at a specific index
1296      *
1297      * @param rep The repetition index (0-indexed)
1298      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1299      */
1300     public ID removeOm125_ProcessingPriority(int rep) throws HL7Exception { 
1301         return (ID) super.removeRepetition(25, rep);
1302     }
1303 
1304 
1305 
1306 
1307     /**
1308      * Returns
1309      * OM1-26: "Reporting Priority" - creates it if necessary
1310      */
1311     public ID getReportingPriority() { 
1312 		ID retVal = this.getTypedField(26, 0);
1313 		return retVal;
1314     }
1315     
1316     /**
1317      * Returns
1318      * OM1-26: "Reporting Priority" - creates it if necessary
1319      */
1320     public ID getOm126_ReportingPriority() { 
1321 		ID retVal = this.getTypedField(26, 0);
1322 		return retVal;
1323     }
1324 
1325 
1326     /**
1327      * Returns all repetitions of Outside Site(s) Where Observation May Be Performed (OM1-27).
1328      */
1329     public CWE[] getOutsideSiteSWhereObservationMayBePerformed() {
1330     	CWE[] retVal = this.getTypedField(27, new CWE[0]);
1331     	return retVal;
1332     }
1333 
1334 
1335     /**
1336      * Returns all repetitions of Outside Site(s) Where Observation May Be Performed (OM1-27).
1337      */
1338     public CWE[] getOm127_OutsideSiteSWhereObservationMayBePerformed() {
1339     	CWE[] retVal = this.getTypedField(27, new CWE[0]);
1340     	return retVal;
1341     }
1342 
1343 
1344     /**
1345      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation May Be Performed (OM1-27).
1346      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1347      * it will return zero.
1348      */
1349     public int getOutsideSiteSWhereObservationMayBePerformedReps() {
1350     	return this.getReps(27);
1351     }
1352 
1353 
1354     /**
1355      * Returns a specific repetition of
1356      * OM1-27: "Outside Site(s) Where Observation May Be Performed" - creates it if necessary
1357      *
1358      * @param rep The repetition index (0-indexed)
1359      */
1360     public CWE getOutsideSiteSWhereObservationMayBePerformed(int rep) { 
1361 		CWE retVal = this.getTypedField(27, rep);
1362 		return retVal;
1363     }
1364 
1365     /**
1366      * Returns a specific repetition of
1367      * OM1-27: "Outside Site(s) Where Observation May Be Performed" - creates it if necessary
1368      *
1369      * @param rep The repetition index (0-indexed)
1370      */
1371     public CWE getOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) { 
1372 		CWE retVal = this.getTypedField(27, rep);
1373 		return retVal;
1374     }
1375 
1376     /**
1377      * Returns a count of the current number of repetitions of Outside Site(s) Where Observation May Be Performed (OM1-27).
1378      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1379      * it will return zero.
1380      */
1381     public int getOm127_OutsideSiteSWhereObservationMayBePerformedReps() {
1382     	return this.getReps(27);
1383     }
1384 
1385 
1386     /**
1387      * Inserts a repetition of
1388      * OM1-27: "Outside Site(s) Where Observation May Be Performed" at a specific index
1389      *
1390      * @param rep The repetition index (0-indexed)
1391      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1392      */
1393     public CWE insertOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1394         return (CWE) super.insertRepetition(27, rep);
1395     }
1396 
1397 
1398     /**
1399      * Inserts a repetition of
1400      * OM1-27: "Outside Site(s) Where Observation May Be Performed" at a specific index
1401      *
1402      * @param rep The repetition index (0-indexed)
1403      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1404      */
1405     public CWE insertOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1406         return (CWE) super.insertRepetition(27, rep);
1407     }
1408 
1409 
1410     /**
1411      * Removes a repetition of
1412      * OM1-27: "Outside Site(s) Where Observation May Be Performed" at a specific index
1413      *
1414      * @param rep The repetition index (0-indexed)
1415      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1416      */
1417     public CWE removeOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1418         return (CWE) super.removeRepetition(27, rep);
1419     }
1420 
1421 
1422     /**
1423      * Removes a repetition of
1424      * OM1-27: "Outside Site(s) Where Observation May Be Performed" at a specific index
1425      *
1426      * @param rep The repetition index (0-indexed)
1427      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1428      */
1429     public CWE removeOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 
1430         return (CWE) super.removeRepetition(27, rep);
1431     }
1432 
1433 
1434 
1435     /**
1436      * Returns all repetitions of Address of Outside Site(s) (OM1-28).
1437      */
1438     public XAD[] getAddressOfOutsideSiteS() {
1439     	XAD[] retVal = this.getTypedField(28, new XAD[0]);
1440     	return retVal;
1441     }
1442 
1443 
1444     /**
1445      * Returns all repetitions of Address of Outside Site(s) (OM1-28).
1446      */
1447     public XAD[] getOm128_AddressOfOutsideSiteS() {
1448     	XAD[] retVal = this.getTypedField(28, new XAD[0]);
1449     	return retVal;
1450     }
1451 
1452 
1453     /**
1454      * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-28).
1455      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1456      * it will return zero.
1457      */
1458     public int getAddressOfOutsideSiteSReps() {
1459     	return this.getReps(28);
1460     }
1461 
1462 
1463     /**
1464      * Returns a specific repetition of
1465      * OM1-28: "Address of Outside Site(s)" - creates it if necessary
1466      *
1467      * @param rep The repetition index (0-indexed)
1468      */
1469     public XAD getAddressOfOutsideSiteS(int rep) { 
1470 		XAD retVal = this.getTypedField(28, rep);
1471 		return retVal;
1472     }
1473 
1474     /**
1475      * Returns a specific repetition of
1476      * OM1-28: "Address of Outside Site(s)" - creates it if necessary
1477      *
1478      * @param rep The repetition index (0-indexed)
1479      */
1480     public XAD getOm128_AddressOfOutsideSiteS(int rep) { 
1481 		XAD retVal = this.getTypedField(28, rep);
1482 		return retVal;
1483     }
1484 
1485     /**
1486      * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-28).
1487      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1488      * it will return zero.
1489      */
1490     public int getOm128_AddressOfOutsideSiteSReps() {
1491     	return this.getReps(28);
1492     }
1493 
1494 
1495     /**
1496      * Inserts a repetition of
1497      * OM1-28: "Address of Outside Site(s)" at a specific index
1498      *
1499      * @param rep The repetition index (0-indexed)
1500      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1501      */
1502     public XAD insertAddressOfOutsideSiteS(int rep) throws HL7Exception { 
1503         return (XAD) super.insertRepetition(28, rep);
1504     }
1505 
1506 
1507     /**
1508      * Inserts a repetition of
1509      * OM1-28: "Address of Outside Site(s)" at a specific index
1510      *
1511      * @param rep The repetition index (0-indexed)
1512      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1513      */
1514     public XAD insertOm128_AddressOfOutsideSiteS(int rep) throws HL7Exception { 
1515         return (XAD) super.insertRepetition(28, rep);
1516     }
1517 
1518 
1519     /**
1520      * Removes a repetition of
1521      * OM1-28: "Address of Outside Site(s)" at a specific index
1522      *
1523      * @param rep The repetition index (0-indexed)
1524      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1525      */
1526     public XAD removeAddressOfOutsideSiteS(int rep) throws HL7Exception { 
1527         return (XAD) super.removeRepetition(28, rep);
1528     }
1529 
1530 
1531     /**
1532      * Removes a repetition of
1533      * OM1-28: "Address of Outside Site(s)" at a specific index
1534      *
1535      * @param rep The repetition index (0-indexed)
1536      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1537      */
1538     public XAD removeOm128_AddressOfOutsideSiteS(int rep) throws HL7Exception { 
1539         return (XAD) super.removeRepetition(28, rep);
1540     }
1541 
1542 
1543 
1544 
1545     /**
1546      * Returns
1547      * OM1-29: "Phone Number of Outside Site" - creates it if necessary
1548      */
1549     public XTN getPhoneNumberOfOutsideSite() { 
1550 		XTN retVal = this.getTypedField(29, 0);
1551 		return retVal;
1552     }
1553     
1554     /**
1555      * Returns
1556      * OM1-29: "Phone Number of Outside Site" - creates it if necessary
1557      */
1558     public XTN getOm129_PhoneNumberOfOutsideSite() { 
1559 		XTN retVal = this.getTypedField(29, 0);
1560 		return retVal;
1561     }
1562 
1563 
1564 
1565     /**
1566      * Returns
1567      * OM1-30: "Confidentiality Code" - creates it if necessary
1568      */
1569     public CWE getConfidentialityCode() { 
1570 		CWE retVal = this.getTypedField(30, 0);
1571 		return retVal;
1572     }
1573     
1574     /**
1575      * Returns
1576      * OM1-30: "Confidentiality Code" - creates it if necessary
1577      */
1578     public CWE getOm130_ConfidentialityCode() { 
1579 		CWE retVal = this.getTypedField(30, 0);
1580 		return retVal;
1581     }
1582 
1583 
1584     /**
1585      * Returns all repetitions of Observations Required to Interpret this Observation (OM1-31).
1586      */
1587     public CWE[] getObservationsRequiredToInterpretThisObservation() {
1588     	CWE[] retVal = this.getTypedField(31, new CWE[0]);
1589     	return retVal;
1590     }
1591 
1592 
1593     /**
1594      * Returns all repetitions of Observations Required to Interpret this Observation (OM1-31).
1595      */
1596     public CWE[] getOm131_ObservationsRequiredToInterpretThisObservation() {
1597     	CWE[] retVal = this.getTypedField(31, new CWE[0]);
1598     	return retVal;
1599     }
1600 
1601 
1602     /**
1603      * Returns a count of the current number of repetitions of Observations Required to Interpret this Observation (OM1-31).
1604      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1605      * it will return zero.
1606      */
1607     public int getObservationsRequiredToInterpretThisObservationReps() {
1608     	return this.getReps(31);
1609     }
1610 
1611 
1612     /**
1613      * Returns a specific repetition of
1614      * OM1-31: "Observations Required to Interpret this Observation" - creates it if necessary
1615      *
1616      * @param rep The repetition index (0-indexed)
1617      */
1618     public CWE getObservationsRequiredToInterpretThisObservation(int rep) { 
1619 		CWE retVal = this.getTypedField(31, rep);
1620 		return retVal;
1621     }
1622 
1623     /**
1624      * Returns a specific repetition of
1625      * OM1-31: "Observations Required to Interpret this Observation" - creates it if necessary
1626      *
1627      * @param rep The repetition index (0-indexed)
1628      */
1629     public CWE getOm131_ObservationsRequiredToInterpretThisObservation(int rep) { 
1630 		CWE retVal = this.getTypedField(31, rep);
1631 		return retVal;
1632     }
1633 
1634     /**
1635      * Returns a count of the current number of repetitions of Observations Required to Interpret this Observation (OM1-31).
1636      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1637      * it will return zero.
1638      */
1639     public int getOm131_ObservationsRequiredToInterpretThisObservationReps() {
1640     	return this.getReps(31);
1641     }
1642 
1643 
1644     /**
1645      * Inserts a repetition of
1646      * OM1-31: "Observations Required to Interpret this Observation" at a specific index
1647      *
1648      * @param rep The repetition index (0-indexed)
1649      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1650      */
1651     public CWE insertObservationsRequiredToInterpretThisObservation(int rep) throws HL7Exception { 
1652         return (CWE) super.insertRepetition(31, rep);
1653     }
1654 
1655 
1656     /**
1657      * Inserts a repetition of
1658      * OM1-31: "Observations Required to Interpret this Observation" at a specific index
1659      *
1660      * @param rep The repetition index (0-indexed)
1661      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1662      */
1663     public CWE insertOm131_ObservationsRequiredToInterpretThisObservation(int rep) throws HL7Exception { 
1664         return (CWE) super.insertRepetition(31, rep);
1665     }
1666 
1667 
1668     /**
1669      * Removes a repetition of
1670      * OM1-31: "Observations Required to Interpret this Observation" at a specific index
1671      *
1672      * @param rep The repetition index (0-indexed)
1673      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1674      */
1675     public CWE removeObservationsRequiredToInterpretThisObservation(int rep) throws HL7Exception { 
1676         return (CWE) super.removeRepetition(31, rep);
1677     }
1678 
1679 
1680     /**
1681      * Removes a repetition of
1682      * OM1-31: "Observations Required to Interpret this Observation" at a specific index
1683      *
1684      * @param rep The repetition index (0-indexed)
1685      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1686      */
1687     public CWE removeOm131_ObservationsRequiredToInterpretThisObservation(int rep) throws HL7Exception { 
1688         return (CWE) super.removeRepetition(31, rep);
1689     }
1690 
1691 
1692 
1693 
1694     /**
1695      * Returns
1696      * OM1-32: "Interpretation of Observations" - creates it if necessary
1697      */
1698     public TX getInterpretationOfObservations() { 
1699 		TX retVal = this.getTypedField(32, 0);
1700 		return retVal;
1701     }
1702     
1703     /**
1704      * Returns
1705      * OM1-32: "Interpretation of Observations" - creates it if necessary
1706      */
1707     public TX getOm132_InterpretationOfObservations() { 
1708 		TX retVal = this.getTypedField(32, 0);
1709 		return retVal;
1710     }
1711 
1712 
1713     /**
1714      * Returns all repetitions of Contraindications to Observations (OM1-33).
1715      */
1716     public CWE[] getContraindicationsToObservations() {
1717     	CWE[] retVal = this.getTypedField(33, new CWE[0]);
1718     	return retVal;
1719     }
1720 
1721 
1722     /**
1723      * Returns all repetitions of Contraindications to Observations (OM1-33).
1724      */
1725     public CWE[] getOm133_ContraindicationsToObservations() {
1726     	CWE[] retVal = this.getTypedField(33, new CWE[0]);
1727     	return retVal;
1728     }
1729 
1730 
1731     /**
1732      * Returns a count of the current number of repetitions of Contraindications to Observations (OM1-33).
1733      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1734      * it will return zero.
1735      */
1736     public int getContraindicationsToObservationsReps() {
1737     	return this.getReps(33);
1738     }
1739 
1740 
1741     /**
1742      * Returns a specific repetition of
1743      * OM1-33: "Contraindications to Observations" - creates it if necessary
1744      *
1745      * @param rep The repetition index (0-indexed)
1746      */
1747     public CWE getContraindicationsToObservations(int rep) { 
1748 		CWE retVal = this.getTypedField(33, rep);
1749 		return retVal;
1750     }
1751 
1752     /**
1753      * Returns a specific repetition of
1754      * OM1-33: "Contraindications to Observations" - creates it if necessary
1755      *
1756      * @param rep The repetition index (0-indexed)
1757      */
1758     public CWE getOm133_ContraindicationsToObservations(int rep) { 
1759 		CWE retVal = this.getTypedField(33, rep);
1760 		return retVal;
1761     }
1762 
1763     /**
1764      * Returns a count of the current number of repetitions of Contraindications to Observations (OM1-33).
1765      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1766      * it will return zero.
1767      */
1768     public int getOm133_ContraindicationsToObservationsReps() {
1769     	return this.getReps(33);
1770     }
1771 
1772 
1773     /**
1774      * Inserts a repetition of
1775      * OM1-33: "Contraindications to Observations" at a specific index
1776      *
1777      * @param rep The repetition index (0-indexed)
1778      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1779      */
1780     public CWE insertContraindicationsToObservations(int rep) throws HL7Exception { 
1781         return (CWE) super.insertRepetition(33, rep);
1782     }
1783 
1784 
1785     /**
1786      * Inserts a repetition of
1787      * OM1-33: "Contraindications to Observations" at a specific index
1788      *
1789      * @param rep The repetition index (0-indexed)
1790      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1791      */
1792     public CWE insertOm133_ContraindicationsToObservations(int rep) throws HL7Exception { 
1793         return (CWE) super.insertRepetition(33, rep);
1794     }
1795 
1796 
1797     /**
1798      * Removes a repetition of
1799      * OM1-33: "Contraindications to Observations" at a specific index
1800      *
1801      * @param rep The repetition index (0-indexed)
1802      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1803      */
1804     public CWE removeContraindicationsToObservations(int rep) throws HL7Exception { 
1805         return (CWE) super.removeRepetition(33, rep);
1806     }
1807 
1808 
1809     /**
1810      * Removes a repetition of
1811      * OM1-33: "Contraindications to Observations" at a specific index
1812      *
1813      * @param rep The repetition index (0-indexed)
1814      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1815      */
1816     public CWE removeOm133_ContraindicationsToObservations(int rep) throws HL7Exception { 
1817         return (CWE) super.removeRepetition(33, rep);
1818     }
1819 
1820 
1821 
1822     /**
1823      * Returns all repetitions of Reflex Tests/Observations (OM1-34).
1824      */
1825     public CWE[] getReflexTestsObservations() {
1826     	CWE[] retVal = this.getTypedField(34, new CWE[0]);
1827     	return retVal;
1828     }
1829 
1830 
1831     /**
1832      * Returns all repetitions of Reflex Tests/Observations (OM1-34).
1833      */
1834     public CWE[] getOm134_ReflexTestsObservations() {
1835     	CWE[] retVal = this.getTypedField(34, new CWE[0]);
1836     	return retVal;
1837     }
1838 
1839 
1840     /**
1841      * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34).
1842      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1843      * it will return zero.
1844      */
1845     public int getReflexTestsObservationsReps() {
1846     	return this.getReps(34);
1847     }
1848 
1849 
1850     /**
1851      * Returns a specific repetition of
1852      * OM1-34: "Reflex Tests/Observations" - creates it if necessary
1853      *
1854      * @param rep The repetition index (0-indexed)
1855      */
1856     public CWE getReflexTestsObservations(int rep) { 
1857 		CWE retVal = this.getTypedField(34, rep);
1858 		return retVal;
1859     }
1860 
1861     /**
1862      * Returns a specific repetition of
1863      * OM1-34: "Reflex Tests/Observations" - creates it if necessary
1864      *
1865      * @param rep The repetition index (0-indexed)
1866      */
1867     public CWE getOm134_ReflexTestsObservations(int rep) { 
1868 		CWE retVal = this.getTypedField(34, rep);
1869 		return retVal;
1870     }
1871 
1872     /**
1873      * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34).
1874      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1875      * it will return zero.
1876      */
1877     public int getOm134_ReflexTestsObservationsReps() {
1878     	return this.getReps(34);
1879     }
1880 
1881 
1882     /**
1883      * Inserts a repetition of
1884      * OM1-34: "Reflex Tests/Observations" at a specific index
1885      *
1886      * @param rep The repetition index (0-indexed)
1887      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1888      */
1889     public CWE insertReflexTestsObservations(int rep) throws HL7Exception { 
1890         return (CWE) super.insertRepetition(34, rep);
1891     }
1892 
1893 
1894     /**
1895      * Inserts a repetition of
1896      * OM1-34: "Reflex Tests/Observations" at a specific index
1897      *
1898      * @param rep The repetition index (0-indexed)
1899      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1900      */
1901     public CWE insertOm134_ReflexTestsObservations(int rep) throws HL7Exception { 
1902         return (CWE) super.insertRepetition(34, rep);
1903     }
1904 
1905 
1906     /**
1907      * Removes a repetition of
1908      * OM1-34: "Reflex Tests/Observations" at a specific index
1909      *
1910      * @param rep The repetition index (0-indexed)
1911      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1912      */
1913     public CWE removeReflexTestsObservations(int rep) throws HL7Exception { 
1914         return (CWE) super.removeRepetition(34, rep);
1915     }
1916 
1917 
1918     /**
1919      * Removes a repetition of
1920      * OM1-34: "Reflex Tests/Observations" at a specific index
1921      *
1922      * @param rep The repetition index (0-indexed)
1923      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1924      */
1925     public CWE removeOm134_ReflexTestsObservations(int rep) throws HL7Exception { 
1926         return (CWE) super.removeRepetition(34, rep);
1927     }
1928 
1929 
1930 
1931     /**
1932      * Returns all repetitions of Rules that Trigger Reflex Testing (OM1-35).
1933      */
1934     public TX[] getRulesThatTriggerReflexTesting() {
1935     	TX[] retVal = this.getTypedField(35, new TX[0]);
1936     	return retVal;
1937     }
1938 
1939 
1940     /**
1941      * Returns all repetitions of Rules that Trigger Reflex Testing (OM1-35).
1942      */
1943     public TX[] getOm135_RulesThatTriggerReflexTesting() {
1944     	TX[] retVal = this.getTypedField(35, new TX[0]);
1945     	return retVal;
1946     }
1947 
1948 
1949     /**
1950      * Returns a count of the current number of repetitions of Rules that Trigger Reflex Testing (OM1-35).
1951      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1952      * it will return zero.
1953      */
1954     public int getRulesThatTriggerReflexTestingReps() {
1955     	return this.getReps(35);
1956     }
1957 
1958 
1959     /**
1960      * Returns a specific repetition of
1961      * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary
1962      *
1963      * @param rep The repetition index (0-indexed)
1964      */
1965     public TX getRulesThatTriggerReflexTesting(int rep) { 
1966 		TX retVal = this.getTypedField(35, rep);
1967 		return retVal;
1968     }
1969 
1970     /**
1971      * Returns a specific repetition of
1972      * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary
1973      *
1974      * @param rep The repetition index (0-indexed)
1975      */
1976     public TX getOm135_RulesThatTriggerReflexTesting(int rep) { 
1977 		TX retVal = this.getTypedField(35, rep);
1978 		return retVal;
1979     }
1980 
1981     /**
1982      * Returns a count of the current number of repetitions of Rules that Trigger Reflex Testing (OM1-35).
1983      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1984      * it will return zero.
1985      */
1986     public int getOm135_RulesThatTriggerReflexTestingReps() {
1987     	return this.getReps(35);
1988     }
1989 
1990 
1991     /**
1992      * Inserts a repetition of
1993      * OM1-35: "Rules that Trigger Reflex Testing" at a specific index
1994      *
1995      * @param rep The repetition index (0-indexed)
1996      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1997      */
1998     public TX insertRulesThatTriggerReflexTesting(int rep) throws HL7Exception { 
1999         return (TX) super.insertRepetition(35, rep);
2000     }
2001 
2002 
2003     /**
2004      * Inserts a repetition of
2005      * OM1-35: "Rules that Trigger Reflex Testing" at a specific index
2006      *
2007      * @param rep The repetition index (0-indexed)
2008      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2009      */
2010     public TX insertOm135_RulesThatTriggerReflexTesting(int rep) throws HL7Exception { 
2011         return (TX) super.insertRepetition(35, rep);
2012     }
2013 
2014 
2015     /**
2016      * Removes a repetition of
2017      * OM1-35: "Rules that Trigger Reflex Testing" at a specific index
2018      *
2019      * @param rep The repetition index (0-indexed)
2020      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2021      */
2022     public TX removeRulesThatTriggerReflexTesting(int rep) throws HL7Exception { 
2023         return (TX) super.removeRepetition(35, rep);
2024     }
2025 
2026 
2027     /**
2028      * Removes a repetition of
2029      * OM1-35: "Rules that Trigger Reflex Testing" at a specific index
2030      *
2031      * @param rep The repetition index (0-indexed)
2032      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2033      */
2034     public TX removeOm135_RulesThatTriggerReflexTesting(int rep) throws HL7Exception { 
2035         return (TX) super.removeRepetition(35, rep);
2036     }
2037 
2038 
2039 
2040     /**
2041      * Returns all repetitions of Fixed Canned Message (OM1-36).
2042      */
2043     public CWE[] getFixedCannedMessage() {
2044     	CWE[] retVal = this.getTypedField(36, new CWE[0]);
2045     	return retVal;
2046     }
2047 
2048 
2049     /**
2050      * Returns all repetitions of Fixed Canned Message (OM1-36).
2051      */
2052     public CWE[] getOm136_FixedCannedMessage() {
2053     	CWE[] retVal = this.getTypedField(36, new CWE[0]);
2054     	return retVal;
2055     }
2056 
2057 
2058     /**
2059      * Returns a count of the current number of repetitions of Fixed Canned Message (OM1-36).
2060      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2061      * it will return zero.
2062      */
2063     public int getFixedCannedMessageReps() {
2064     	return this.getReps(36);
2065     }
2066 
2067 
2068     /**
2069      * Returns a specific repetition of
2070      * OM1-36: "Fixed Canned Message" - creates it if necessary
2071      *
2072      * @param rep The repetition index (0-indexed)
2073      */
2074     public CWE getFixedCannedMessage(int rep) { 
2075 		CWE retVal = this.getTypedField(36, rep);
2076 		return retVal;
2077     }
2078 
2079     /**
2080      * Returns a specific repetition of
2081      * OM1-36: "Fixed Canned Message" - creates it if necessary
2082      *
2083      * @param rep The repetition index (0-indexed)
2084      */
2085     public CWE getOm136_FixedCannedMessage(int rep) { 
2086 		CWE retVal = this.getTypedField(36, rep);
2087 		return retVal;
2088     }
2089 
2090     /**
2091      * Returns a count of the current number of repetitions of Fixed Canned Message (OM1-36).
2092      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2093      * it will return zero.
2094      */
2095     public int getOm136_FixedCannedMessageReps() {
2096     	return this.getReps(36);
2097     }
2098 
2099 
2100     /**
2101      * Inserts a repetition of
2102      * OM1-36: "Fixed Canned Message" at a specific index
2103      *
2104      * @param rep The repetition index (0-indexed)
2105      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2106      */
2107     public CWE insertFixedCannedMessage(int rep) throws HL7Exception { 
2108         return (CWE) super.insertRepetition(36, rep);
2109     }
2110 
2111 
2112     /**
2113      * Inserts a repetition of
2114      * OM1-36: "Fixed Canned Message" at a specific index
2115      *
2116      * @param rep The repetition index (0-indexed)
2117      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2118      */
2119     public CWE insertOm136_FixedCannedMessage(int rep) throws HL7Exception { 
2120         return (CWE) super.insertRepetition(36, rep);
2121     }
2122 
2123 
2124     /**
2125      * Removes a repetition of
2126      * OM1-36: "Fixed Canned Message" at a specific index
2127      *
2128      * @param rep The repetition index (0-indexed)
2129      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2130      */
2131     public CWE removeFixedCannedMessage(int rep) throws HL7Exception { 
2132         return (CWE) super.removeRepetition(36, rep);
2133     }
2134 
2135 
2136     /**
2137      * Removes a repetition of
2138      * OM1-36: "Fixed Canned Message" at a specific index
2139      *
2140      * @param rep The repetition index (0-indexed)
2141      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2142      */
2143     public CWE removeOm136_FixedCannedMessage(int rep) throws HL7Exception { 
2144         return (CWE) super.removeRepetition(36, rep);
2145     }
2146 
2147 
2148 
2149     /**
2150      * Returns all repetitions of Patient Preparation (OM1-37).
2151      */
2152     public TX[] getPatientPreparation() {
2153     	TX[] retVal = this.getTypedField(37, new TX[0]);
2154     	return retVal;
2155     }
2156 
2157 
2158     /**
2159      * Returns all repetitions of Patient Preparation (OM1-37).
2160      */
2161     public TX[] getOm137_PatientPreparation() {
2162     	TX[] retVal = this.getTypedField(37, new TX[0]);
2163     	return retVal;
2164     }
2165 
2166 
2167     /**
2168      * Returns a count of the current number of repetitions of Patient Preparation (OM1-37).
2169      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2170      * it will return zero.
2171      */
2172     public int getPatientPreparationReps() {
2173     	return this.getReps(37);
2174     }
2175 
2176 
2177     /**
2178      * Returns a specific repetition of
2179      * OM1-37: "Patient Preparation" - creates it if necessary
2180      *
2181      * @param rep The repetition index (0-indexed)
2182      */
2183     public TX getPatientPreparation(int rep) { 
2184 		TX retVal = this.getTypedField(37, rep);
2185 		return retVal;
2186     }
2187 
2188     /**
2189      * Returns a specific repetition of
2190      * OM1-37: "Patient Preparation" - creates it if necessary
2191      *
2192      * @param rep The repetition index (0-indexed)
2193      */
2194     public TX getOm137_PatientPreparation(int rep) { 
2195 		TX retVal = this.getTypedField(37, rep);
2196 		return retVal;
2197     }
2198 
2199     /**
2200      * Returns a count of the current number of repetitions of Patient Preparation (OM1-37).
2201      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2202      * it will return zero.
2203      */
2204     public int getOm137_PatientPreparationReps() {
2205     	return this.getReps(37);
2206     }
2207 
2208 
2209     /**
2210      * Inserts a repetition of
2211      * OM1-37: "Patient Preparation" at a specific index
2212      *
2213      * @param rep The repetition index (0-indexed)
2214      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2215      */
2216     public TX insertPatientPreparation(int rep) throws HL7Exception { 
2217         return (TX) super.insertRepetition(37, rep);
2218     }
2219 
2220 
2221     /**
2222      * Inserts a repetition of
2223      * OM1-37: "Patient Preparation" at a specific index
2224      *
2225      * @param rep The repetition index (0-indexed)
2226      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2227      */
2228     public TX insertOm137_PatientPreparation(int rep) throws HL7Exception { 
2229         return (TX) super.insertRepetition(37, rep);
2230     }
2231 
2232 
2233     /**
2234      * Removes a repetition of
2235      * OM1-37: "Patient Preparation" at a specific index
2236      *
2237      * @param rep The repetition index (0-indexed)
2238      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2239      */
2240     public TX removePatientPreparation(int rep) throws HL7Exception { 
2241         return (TX) super.removeRepetition(37, rep);
2242     }
2243 
2244 
2245     /**
2246      * Removes a repetition of
2247      * OM1-37: "Patient Preparation" at a specific index
2248      *
2249      * @param rep The repetition index (0-indexed)
2250      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2251      */
2252     public TX removeOm137_PatientPreparation(int rep) throws HL7Exception { 
2253         return (TX) super.removeRepetition(37, rep);
2254     }
2255 
2256 
2257 
2258 
2259     /**
2260      * Returns
2261      * OM1-38: "Procedure Medication" - creates it if necessary
2262      */
2263     public CWE getProcedureMedication() { 
2264 		CWE retVal = this.getTypedField(38, 0);
2265 		return retVal;
2266     }
2267     
2268     /**
2269      * Returns
2270      * OM1-38: "Procedure Medication" - creates it if necessary
2271      */
2272     public CWE getOm138_ProcedureMedication() { 
2273 		CWE retVal = this.getTypedField(38, 0);
2274 		return retVal;
2275     }
2276 
2277 
2278 
2279     /**
2280      * Returns
2281      * OM1-39: "Factors that may Affect the Observation" - creates it if necessary
2282      */
2283     public TX getFactorsThatMayAffectTheObservation() { 
2284 		TX retVal = this.getTypedField(39, 0);
2285 		return retVal;
2286     }
2287     
2288     /**
2289      * Returns
2290      * OM1-39: "Factors that may Affect the Observation" - creates it if necessary
2291      */
2292     public TX getOm139_FactorsThatMayAffectTheObservation() { 
2293 		TX retVal = this.getTypedField(39, 0);
2294 		return retVal;
2295     }
2296 
2297 
2298     /**
2299      * Returns all repetitions of Service/Test/Observation Performance Schedule (OM1-40).
2300      */
2301     public ST[] getServiceTestObservationPerformanceSchedule() {
2302     	ST[] retVal = this.getTypedField(40, new ST[0]);
2303     	return retVal;
2304     }
2305 
2306 
2307     /**
2308      * Returns all repetitions of Service/Test/Observation Performance Schedule (OM1-40).
2309      */
2310     public ST[] getOm140_ServiceTestObservationPerformanceSchedule() {
2311     	ST[] retVal = this.getTypedField(40, new ST[0]);
2312     	return retVal;
2313     }
2314 
2315 
2316     /**
2317      * Returns a count of the current number of repetitions of Service/Test/Observation Performance Schedule (OM1-40).
2318      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2319      * it will return zero.
2320      */
2321     public int getServiceTestObservationPerformanceScheduleReps() {
2322     	return this.getReps(40);
2323     }
2324 
2325 
2326     /**
2327      * Returns a specific repetition of
2328      * OM1-40: "Service/Test/Observation Performance Schedule" - creates it if necessary
2329      *
2330      * @param rep The repetition index (0-indexed)
2331      */
2332     public ST getServiceTestObservationPerformanceSchedule(int rep) { 
2333 		ST retVal = this.getTypedField(40, rep);
2334 		return retVal;
2335     }
2336 
2337     /**
2338      * Returns a specific repetition of
2339      * OM1-40: "Service/Test/Observation Performance Schedule" - creates it if necessary
2340      *
2341      * @param rep The repetition index (0-indexed)
2342      */
2343     public ST getOm140_ServiceTestObservationPerformanceSchedule(int rep) { 
2344 		ST retVal = this.getTypedField(40, rep);
2345 		return retVal;
2346     }
2347 
2348     /**
2349      * Returns a count of the current number of repetitions of Service/Test/Observation Performance Schedule (OM1-40).
2350      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2351      * it will return zero.
2352      */
2353     public int getOm140_ServiceTestObservationPerformanceScheduleReps() {
2354     	return this.getReps(40);
2355     }
2356 
2357 
2358     /**
2359      * Inserts a repetition of
2360      * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index
2361      *
2362      * @param rep The repetition index (0-indexed)
2363      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2364      */
2365     public ST insertServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2366         return (ST) super.insertRepetition(40, rep);
2367     }
2368 
2369 
2370     /**
2371      * Inserts a repetition of
2372      * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index
2373      *
2374      * @param rep The repetition index (0-indexed)
2375      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2376      */
2377     public ST insertOm140_ServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2378         return (ST) super.insertRepetition(40, rep);
2379     }
2380 
2381 
2382     /**
2383      * Removes a repetition of
2384      * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index
2385      *
2386      * @param rep The repetition index (0-indexed)
2387      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2388      */
2389     public ST removeServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2390         return (ST) super.removeRepetition(40, rep);
2391     }
2392 
2393 
2394     /**
2395      * Removes a repetition of
2396      * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index
2397      *
2398      * @param rep The repetition index (0-indexed)
2399      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2400      */
2401     public ST removeOm140_ServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 
2402         return (ST) super.removeRepetition(40, rep);
2403     }
2404 
2405 
2406 
2407 
2408     /**
2409      * Returns
2410      * OM1-41: "Description of Test Methods" - creates it if necessary
2411      */
2412     public TX getDescriptionOfTestMethods() { 
2413 		TX retVal = this.getTypedField(41, 0);
2414 		return retVal;
2415     }
2416     
2417     /**
2418      * Returns
2419      * OM1-41: "Description of Test Methods" - creates it if necessary
2420      */
2421     public TX getOm141_DescriptionOfTestMethods() { 
2422 		TX retVal = this.getTypedField(41, 0);
2423 		return retVal;
2424     }
2425 
2426 
2427 
2428     /**
2429      * Returns
2430      * OM1-42: "Kind of Quantity Observed" - creates it if necessary
2431      */
2432     public CWE getKindOfQuantityObserved() { 
2433 		CWE retVal = this.getTypedField(42, 0);
2434 		return retVal;
2435     }
2436     
2437     /**
2438      * Returns
2439      * OM1-42: "Kind of Quantity Observed" - creates it if necessary
2440      */
2441     public CWE getOm142_KindOfQuantityObserved() { 
2442 		CWE retVal = this.getTypedField(42, 0);
2443 		return retVal;
2444     }
2445 
2446 
2447 
2448     /**
2449      * Returns
2450      * OM1-43: "Point Versus Interval" - creates it if necessary
2451      */
2452     public CWE getPointVersusInterval() { 
2453 		CWE retVal = this.getTypedField(43, 0);
2454 		return retVal;
2455     }
2456     
2457     /**
2458      * Returns
2459      * OM1-43: "Point Versus Interval" - creates it if necessary
2460      */
2461     public CWE getOm143_PointVersusInterval() { 
2462 		CWE retVal = this.getTypedField(43, 0);
2463 		return retVal;
2464     }
2465 
2466 
2467 
2468     /**
2469      * Returns
2470      * OM1-44: "Challenge Information" - creates it if necessary
2471      */
2472     public TX getChallengeInformation() { 
2473 		TX retVal = this.getTypedField(44, 0);
2474 		return retVal;
2475     }
2476     
2477     /**
2478      * Returns
2479      * OM1-44: "Challenge Information" - creates it if necessary
2480      */
2481     public TX getOm144_ChallengeInformation() { 
2482 		TX retVal = this.getTypedField(44, 0);
2483 		return retVal;
2484     }
2485 
2486 
2487 
2488     /**
2489      * Returns
2490      * OM1-45: "Relationship Modifier" - creates it if necessary
2491      */
2492     public CWE getRelationshipModifier() { 
2493 		CWE retVal = this.getTypedField(45, 0);
2494 		return retVal;
2495     }
2496     
2497     /**
2498      * Returns
2499      * OM1-45: "Relationship Modifier" - creates it if necessary
2500      */
2501     public CWE getOm145_RelationshipModifier() { 
2502 		CWE retVal = this.getTypedField(45, 0);
2503 		return retVal;
2504     }
2505 
2506 
2507 
2508     /**
2509      * Returns
2510      * OM1-46: "Target Anatomic Site Of Test" - creates it if necessary
2511      */
2512     public CWE getTargetAnatomicSiteOfTest() { 
2513 		CWE retVal = this.getTypedField(46, 0);
2514 		return retVal;
2515     }
2516     
2517     /**
2518      * Returns
2519      * OM1-46: "Target Anatomic Site Of Test" - creates it if necessary
2520      */
2521     public CWE getOm146_TargetAnatomicSiteOfTest() { 
2522 		CWE retVal = this.getTypedField(46, 0);
2523 		return retVal;
2524     }
2525 
2526 
2527 
2528     /**
2529      * Returns
2530      * OM1-47: "Modality of Imaging Measurement" - creates it if necessary
2531      */
2532     public CWE getModalityOfImagingMeasurement() { 
2533 		CWE retVal = this.getTypedField(47, 0);
2534 		return retVal;
2535     }
2536     
2537     /**
2538      * Returns
2539      * OM1-47: "Modality of Imaging Measurement" - creates it if necessary
2540      */
2541     public CWE getOm147_ModalityOfImagingMeasurement() { 
2542 		CWE retVal = this.getTypedField(47, 0);
2543 		return retVal;
2544     }
2545 
2546 
2547 
2548     /**
2549      * Returns
2550      * OM1-48: "Exclusive Test" - creates it if necessary
2551      */
2552     public ID getExclusiveTest() { 
2553 		ID retVal = this.getTypedField(48, 0);
2554 		return retVal;
2555     }
2556     
2557     /**
2558      * Returns
2559      * OM1-48: "Exclusive Test" - creates it if necessary
2560      */
2561     public ID getOm148_ExclusiveTest() { 
2562 		ID retVal = this.getTypedField(48, 0);
2563 		return retVal;
2564     }
2565 
2566 
2567 
2568     /**
2569      * Returns
2570      * OM1-49: "Diagnostic Serv Sect ID" - creates it if necessary
2571      */
2572     public ID getDiagnosticServSectID() { 
2573 		ID retVal = this.getTypedField(49, 0);
2574 		return retVal;
2575     }
2576     
2577     /**
2578      * Returns
2579      * OM1-49: "Diagnostic Serv Sect ID" - creates it if necessary
2580      */
2581     public ID getOm149_DiagnosticServSectID() { 
2582 		ID retVal = this.getTypedField(49, 0);
2583 		return retVal;
2584     }
2585 
2586 
2587 
2588     /**
2589      * Returns
2590      * OM1-50: "Taxonomic Classification Code" - creates it if necessary
2591      */
2592     public CWE getTaxonomicClassificationCode() { 
2593 		CWE retVal = this.getTypedField(50, 0);
2594 		return retVal;
2595     }
2596     
2597     /**
2598      * Returns
2599      * OM1-50: "Taxonomic Classification Code" - creates it if necessary
2600      */
2601     public CWE getOm150_TaxonomicClassificationCode() { 
2602 		CWE retVal = this.getTypedField(50, 0);
2603 		return retVal;
2604     }
2605 
2606 
2607     /**
2608      * Returns all repetitions of Other Names Number 2 (OM1-51).
2609      */
2610     public ST[] getOtherNamesNumber2() {
2611     	ST[] retVal = this.getTypedField(51, new ST[0]);
2612     	return retVal;
2613     }
2614 
2615 
2616     /**
2617      * Returns all repetitions of Other Names Number 2 (OM1-51).
2618      */
2619     public ST[] getOm151_OtherNamesNumber2() {
2620     	ST[] retVal = this.getTypedField(51, new ST[0]);
2621     	return retVal;
2622     }
2623 
2624 
2625     /**
2626      * Returns a count of the current number of repetitions of Other Names Number 2 (OM1-51).
2627      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2628      * it will return zero.
2629      */
2630     public int getOtherNamesNumber2Reps() {
2631     	return this.getReps(51);
2632     }
2633 
2634 
2635     /**
2636      * Returns a specific repetition of
2637      * OM1-51: "Other Names Number 2" - creates it if necessary
2638      *
2639      * @param rep The repetition index (0-indexed)
2640      */
2641     public ST getOtherNamesNumber2(int rep) { 
2642 		ST retVal = this.getTypedField(51, rep);
2643 		return retVal;
2644     }
2645 
2646     /**
2647      * Returns a specific repetition of
2648      * OM1-51: "Other Names Number 2" - creates it if necessary
2649      *
2650      * @param rep The repetition index (0-indexed)
2651      */
2652     public ST getOm151_OtherNamesNumber2(int rep) { 
2653 		ST retVal = this.getTypedField(51, rep);
2654 		return retVal;
2655     }
2656 
2657     /**
2658      * Returns a count of the current number of repetitions of Other Names Number 2 (OM1-51).
2659      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2660      * it will return zero.
2661      */
2662     public int getOm151_OtherNamesNumber2Reps() {
2663     	return this.getReps(51);
2664     }
2665 
2666 
2667     /**
2668      * Inserts a repetition of
2669      * OM1-51: "Other Names Number 2" at a specific index
2670      *
2671      * @param rep The repetition index (0-indexed)
2672      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2673      */
2674     public ST insertOtherNamesNumber2(int rep) throws HL7Exception { 
2675         return (ST) super.insertRepetition(51, rep);
2676     }
2677 
2678 
2679     /**
2680      * Inserts a repetition of
2681      * OM1-51: "Other Names Number 2" at a specific index
2682      *
2683      * @param rep The repetition index (0-indexed)
2684      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2685      */
2686     public ST insertOm151_OtherNamesNumber2(int rep) throws HL7Exception { 
2687         return (ST) super.insertRepetition(51, rep);
2688     }
2689 
2690 
2691     /**
2692      * Removes a repetition of
2693      * OM1-51: "Other Names Number 2" at a specific index
2694      *
2695      * @param rep The repetition index (0-indexed)
2696      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2697      */
2698     public ST removeOtherNamesNumber2(int rep) throws HL7Exception { 
2699         return (ST) super.removeRepetition(51, rep);
2700     }
2701 
2702 
2703     /**
2704      * Removes a repetition of
2705      * OM1-51: "Other Names Number 2" at a specific index
2706      *
2707      * @param rep The repetition index (0-indexed)
2708      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2709      */
2710     public ST removeOm151_OtherNamesNumber2(int rep) throws HL7Exception { 
2711         return (ST) super.removeRepetition(51, rep);
2712     }
2713 
2714 
2715 
2716     /**
2717      * Returns all repetitions of Replacement Producer's Service/Test/Observation ID (OM1-52).
2718      */
2719     public CWE[] getReplacementProducerSServiceTestObservationID() {
2720     	CWE[] retVal = this.getTypedField(52, new CWE[0]);
2721     	return retVal;
2722     }
2723 
2724 
2725     /**
2726      * Returns all repetitions of Replacement Producer's Service/Test/Observation ID (OM1-52).
2727      */
2728     public CWE[] getOm152_ReplacementProducerSServiceTestObservationID() {
2729     	CWE[] retVal = this.getTypedField(52, new CWE[0]);
2730     	return retVal;
2731     }
2732 
2733 
2734     /**
2735      * Returns a count of the current number of repetitions of Replacement Producer's Service/Test/Observation ID (OM1-52).
2736      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2737      * it will return zero.
2738      */
2739     public int getReplacementProducerSServiceTestObservationIDReps() {
2740     	return this.getReps(52);
2741     }
2742 
2743 
2744     /**
2745      * Returns a specific repetition of
2746      * OM1-52: "Replacement Producer's Service/Test/Observation ID" - creates it if necessary
2747      *
2748      * @param rep The repetition index (0-indexed)
2749      */
2750     public CWE getReplacementProducerSServiceTestObservationID(int rep) { 
2751 		CWE retVal = this.getTypedField(52, rep);
2752 		return retVal;
2753     }
2754 
2755     /**
2756      * Returns a specific repetition of
2757      * OM1-52: "Replacement Producer's Service/Test/Observation ID" - creates it if necessary
2758      *
2759      * @param rep The repetition index (0-indexed)
2760      */
2761     public CWE getOm152_ReplacementProducerSServiceTestObservationID(int rep) { 
2762 		CWE retVal = this.getTypedField(52, rep);
2763 		return retVal;
2764     }
2765 
2766     /**
2767      * Returns a count of the current number of repetitions of Replacement Producer's Service/Test/Observation ID (OM1-52).
2768      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2769      * it will return zero.
2770      */
2771     public int getOm152_ReplacementProducerSServiceTestObservationIDReps() {
2772     	return this.getReps(52);
2773     }
2774 
2775 
2776     /**
2777      * Inserts a repetition of
2778      * OM1-52: "Replacement Producer's Service/Test/Observation ID" at a specific index
2779      *
2780      * @param rep The repetition index (0-indexed)
2781      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2782      */
2783     public CWE insertReplacementProducerSServiceTestObservationID(int rep) throws HL7Exception { 
2784         return (CWE) super.insertRepetition(52, rep);
2785     }
2786 
2787 
2788     /**
2789      * Inserts a repetition of
2790      * OM1-52: "Replacement Producer's Service/Test/Observation ID" at a specific index
2791      *
2792      * @param rep The repetition index (0-indexed)
2793      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2794      */
2795     public CWE insertOm152_ReplacementProducerSServiceTestObservationID(int rep) throws HL7Exception { 
2796         return (CWE) super.insertRepetition(52, rep);
2797     }
2798 
2799 
2800     /**
2801      * Removes a repetition of
2802      * OM1-52: "Replacement Producer's Service/Test/Observation ID" at a specific index
2803      *
2804      * @param rep The repetition index (0-indexed)
2805      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2806      */
2807     public CWE removeReplacementProducerSServiceTestObservationID(int rep) throws HL7Exception { 
2808         return (CWE) super.removeRepetition(52, rep);
2809     }
2810 
2811 
2812     /**
2813      * Removes a repetition of
2814      * OM1-52: "Replacement Producer's Service/Test/Observation ID" at a specific index
2815      *
2816      * @param rep The repetition index (0-indexed)
2817      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2818      */
2819     public CWE removeOm152_ReplacementProducerSServiceTestObservationID(int rep) throws HL7Exception { 
2820         return (CWE) super.removeRepetition(52, rep);
2821     }
2822 
2823 
2824 
2825     /**
2826      * Returns all repetitions of Prior Resuts Instructions (OM1-53).
2827      */
2828     public TX[] getPriorResutsInstructions() {
2829     	TX[] retVal = this.getTypedField(53, new TX[0]);
2830     	return retVal;
2831     }
2832 
2833 
2834     /**
2835      * Returns all repetitions of Prior Resuts Instructions (OM1-53).
2836      */
2837     public TX[] getOm153_PriorResutsInstructions() {
2838     	TX[] retVal = this.getTypedField(53, new TX[0]);
2839     	return retVal;
2840     }
2841 
2842 
2843     /**
2844      * Returns a count of the current number of repetitions of Prior Resuts Instructions (OM1-53).
2845      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2846      * it will return zero.
2847      */
2848     public int getPriorResutsInstructionsReps() {
2849     	return this.getReps(53);
2850     }
2851 
2852 
2853     /**
2854      * Returns a specific repetition of
2855      * OM1-53: "Prior Resuts Instructions" - creates it if necessary
2856      *
2857      * @param rep The repetition index (0-indexed)
2858      */
2859     public TX getPriorResutsInstructions(int rep) { 
2860 		TX retVal = this.getTypedField(53, rep);
2861 		return retVal;
2862     }
2863 
2864     /**
2865      * Returns a specific repetition of
2866      * OM1-53: "Prior Resuts Instructions" - creates it if necessary
2867      *
2868      * @param rep The repetition index (0-indexed)
2869      */
2870     public TX getOm153_PriorResutsInstructions(int rep) { 
2871 		TX retVal = this.getTypedField(53, rep);
2872 		return retVal;
2873     }
2874 
2875     /**
2876      * Returns a count of the current number of repetitions of Prior Resuts Instructions (OM1-53).
2877      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2878      * it will return zero.
2879      */
2880     public int getOm153_PriorResutsInstructionsReps() {
2881     	return this.getReps(53);
2882     }
2883 
2884 
2885     /**
2886      * Inserts a repetition of
2887      * OM1-53: "Prior Resuts Instructions" at a specific index
2888      *
2889      * @param rep The repetition index (0-indexed)
2890      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2891      */
2892     public TX insertPriorResutsInstructions(int rep) throws HL7Exception { 
2893         return (TX) super.insertRepetition(53, rep);
2894     }
2895 
2896 
2897     /**
2898      * Inserts a repetition of
2899      * OM1-53: "Prior Resuts Instructions" at a specific index
2900      *
2901      * @param rep The repetition index (0-indexed)
2902      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2903      */
2904     public TX insertOm153_PriorResutsInstructions(int rep) throws HL7Exception { 
2905         return (TX) super.insertRepetition(53, rep);
2906     }
2907 
2908 
2909     /**
2910      * Removes a repetition of
2911      * OM1-53: "Prior Resuts Instructions" at a specific index
2912      *
2913      * @param rep The repetition index (0-indexed)
2914      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2915      */
2916     public TX removePriorResutsInstructions(int rep) throws HL7Exception { 
2917         return (TX) super.removeRepetition(53, rep);
2918     }
2919 
2920 
2921     /**
2922      * Removes a repetition of
2923      * OM1-53: "Prior Resuts Instructions" at a specific index
2924      *
2925      * @param rep The repetition index (0-indexed)
2926      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2927      */
2928     public TX removeOm153_PriorResutsInstructions(int rep) throws HL7Exception { 
2929         return (TX) super.removeRepetition(53, rep);
2930     }
2931 
2932 
2933 
2934 
2935     /**
2936      * Returns
2937      * OM1-54: "Special Instructions" - creates it if necessary
2938      */
2939     public TX getSpecialInstructions() { 
2940 		TX retVal = this.getTypedField(54, 0);
2941 		return retVal;
2942     }
2943     
2944     /**
2945      * Returns
2946      * OM1-54: "Special Instructions" - creates it if necessary
2947      */
2948     public TX getOm154_SpecialInstructions() { 
2949 		TX retVal = this.getTypedField(54, 0);
2950 		return retVal;
2951     }
2952 
2953 
2954     /**
2955      * Returns all repetitions of Test Category (OM1-55).
2956      */
2957     public CWE[] getTestCategory() {
2958     	CWE[] retVal = this.getTypedField(55, new CWE[0]);
2959     	return retVal;
2960     }
2961 
2962 
2963     /**
2964      * Returns all repetitions of Test Category (OM1-55).
2965      */
2966     public CWE[] getOm155_TestCategory() {
2967     	CWE[] retVal = this.getTypedField(55, new CWE[0]);
2968     	return retVal;
2969     }
2970 
2971 
2972     /**
2973      * Returns a count of the current number of repetitions of Test Category (OM1-55).
2974      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2975      * it will return zero.
2976      */
2977     public int getTestCategoryReps() {
2978     	return this.getReps(55);
2979     }
2980 
2981 
2982     /**
2983      * Returns a specific repetition of
2984      * OM1-55: "Test Category" - creates it if necessary
2985      *
2986      * @param rep The repetition index (0-indexed)
2987      */
2988     public CWE getTestCategory(int rep) { 
2989 		CWE retVal = this.getTypedField(55, rep);
2990 		return retVal;
2991     }
2992 
2993     /**
2994      * Returns a specific repetition of
2995      * OM1-55: "Test Category" - creates it if necessary
2996      *
2997      * @param rep The repetition index (0-indexed)
2998      */
2999     public CWE getOm155_TestCategory(int rep) { 
3000 		CWE retVal = this.getTypedField(55, rep);
3001 		return retVal;
3002     }
3003 
3004     /**
3005      * Returns a count of the current number of repetitions of Test Category (OM1-55).
3006      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
3007      * it will return zero.
3008      */
3009     public int getOm155_TestCategoryReps() {
3010     	return this.getReps(55);
3011     }
3012 
3013 
3014     /**
3015      * Inserts a repetition of
3016      * OM1-55: "Test Category" at a specific index
3017      *
3018      * @param rep The repetition index (0-indexed)
3019      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
3020      */
3021     public CWE insertTestCategory(int rep) throws HL7Exception { 
3022         return (CWE) super.insertRepetition(55, rep);
3023     }
3024 
3025 
3026     /**
3027      * Inserts a repetition of
3028      * OM1-55: "Test Category" at a specific index
3029      *
3030      * @param rep The repetition index (0-indexed)
3031      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
3032      */
3033     public CWE insertOm155_TestCategory(int rep) throws HL7Exception { 
3034         return (CWE) super.insertRepetition(55, rep);
3035     }
3036 
3037 
3038     /**
3039      * Removes a repetition of
3040      * OM1-55: "Test Category" at a specific index
3041      *
3042      * @param rep The repetition index (0-indexed)
3043      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
3044      */
3045     public CWE removeTestCategory(int rep) throws HL7Exception { 
3046         return (CWE) super.removeRepetition(55, rep);
3047     }
3048 
3049 
3050     /**
3051      * Removes a repetition of
3052      * OM1-55: "Test Category" at a specific index
3053      *
3054      * @param rep The repetition index (0-indexed)
3055      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
3056      */
3057     public CWE removeOm155_TestCategory(int rep) throws HL7Exception { 
3058         return (CWE) super.removeRepetition(55, rep);
3059     }
3060 
3061 
3062 
3063 
3064 
3065 
3066     /** {@inheritDoc} */   
3067     protected Type createNewTypeWithoutReflection(int field) {
3068        switch (field) {
3069           case 0: return new NM(getMessage());
3070           case 1: return new CWE(getMessage());
3071           case 2: return new ID(getMessage(), new Integer( 125 ));
3072           case 3: return new ID(getMessage(), new Integer( 136 ));
3073           case 4: return new CWE(getMessage());
3074           case 5: return new TX(getMessage());
3075           case 6: return new CWE(getMessage());
3076           case 7: return new ST(getMessage());
3077           case 8: return new ST(getMessage());
3078           case 9: return new ST(getMessage());
3079           case 10: return new ST(getMessage());
3080           case 11: return new ID(getMessage(), new Integer( 136 ));
3081           case 12: return new CWE(getMessage());
3082           case 13: return new CWE(getMessage());
3083           case 14: return new ID(getMessage(), new Integer( 136 ));
3084           case 15: return new CWE(getMessage());
3085           case 16: return new XTN(getMessage());
3086           case 17: return new CWE(getMessage());
3087           case 18: return new CWE(getMessage());
3088           case 19: return new ST(getMessage());
3089           case 20: return new DTM(getMessage());
3090           case 21: return new DTM(getMessage());
3091           case 22: return new NM(getMessage());
3092           case 23: return new NM(getMessage());
3093           case 24: return new ID(getMessage(), new Integer( 168 ));
3094           case 25: return new ID(getMessage(), new Integer( 169 ));
3095           case 26: return new CWE(getMessage());
3096           case 27: return new XAD(getMessage());
3097           case 28: return new XTN(getMessage());
3098           case 29: return new CWE(getMessage());
3099           case 30: return new CWE(getMessage());
3100           case 31: return new TX(getMessage());
3101           case 32: return new CWE(getMessage());
3102           case 33: return new CWE(getMessage());
3103           case 34: return new TX(getMessage());
3104           case 35: return new CWE(getMessage());
3105           case 36: return new TX(getMessage());
3106           case 37: return new CWE(getMessage());
3107           case 38: return new TX(getMessage());
3108           case 39: return new ST(getMessage());
3109           case 40: return new TX(getMessage());
3110           case 41: return new CWE(getMessage());
3111           case 42: return new CWE(getMessage());
3112           case 43: return new TX(getMessage());
3113           case 44: return new CWE(getMessage());
3114           case 45: return new CWE(getMessage());
3115           case 46: return new CWE(getMessage());
3116           case 47: return new ID(getMessage(), new Integer( 919 ));
3117           case 48: return new ID(getMessage(), new Integer( 74 ));
3118           case 49: return new CWE(getMessage());
3119           case 50: return new ST(getMessage());
3120           case 51: return new CWE(getMessage());
3121           case 52: return new TX(getMessage());
3122           case 53: return new TX(getMessage());
3123           case 54: return new CWE(getMessage());
3124           default: return null;
3125        }
3126    }
3127 
3128 
3129 }
3130