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