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