Source code

001/*
002 * This class is an auto-generated source file for a HAPI
003 * HL7 v2.x standard structure class.
004 *
005 * For more information, visit: http://hl7api.sourceforge.net/
006 * 
007 * The contents of this file are subject to the Mozilla Public License Version 1.1 
008 * (the "License"); you may not use this file except in compliance with the License. 
009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
010 * Software distributed under the License is distributed on an "AS IS" basis, 
011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
012 * specific language governing rights and limitations under the License. 
013 * 
014 * The Original Code is "[file_name]".  Description: 
015 * "[one_line_description]" 
016 * 
017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
018 * 2012.  All Rights Reserved. 
019 * 
020 * Contributor(s): ______________________________________. 
021 * 
022 * Alternatively, the contents of this file may be used under the terms of the 
023 * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
024 * applicable instead of those above.  If you wish to allow use of your version of this 
025 * file only under the terms of the GPL and not to allow others to use your version 
026 * of this file under the MPL, indicate your decision by deleting  the provisions above 
027 * and replace  them with the notice and other provisions required by the GPL License.  
028 * If you do not delete the provisions above, a recipient may use your version of 
029 * this file under either the MPL or the GPL. 
030 * 
031 */
032
033
034package ca.uhn.hl7v2.model.v251.segment;
035
036// import ca.uhn.hl7v2.model.v251.group.*;
037import ca.uhn.hl7v2.model.v251.datatype.*;
038import ca.uhn.hl7v2.HL7Exception;
039import ca.uhn.hl7v2.parser.ModelClassFactory;
040import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
041import ca.uhn.hl7v2.model.AbstractMessage;
042import ca.uhn.hl7v2.model.Group;
043import ca.uhn.hl7v2.model.Type;
044import ca.uhn.hl7v2.model.AbstractSegment;
045import ca.uhn.hl7v2.model.Varies;
046
047/**
048 *<p>Represents an HL7 PID message segment (Patient Identification). 
049 * This segment has the following fields:</p>
050 * <ul>
051     * <li>PID-1: Set ID - PID (SI) <b>optional </b>
052     * <li>PID-2: Patient ID (CX) <b>optional </b>
053     * <li>PID-3: Patient Identifier List (CX) <b> repeating</b>
054     * <li>PID-4: Alternate Patient ID - PID (CX) <b>optional repeating</b>
055     * <li>PID-5: Patient Name (XPN) <b> repeating</b>
056     * <li>PID-6: Mother's Maiden Name (XPN) <b>optional repeating</b>
057     * <li>PID-7: Date/Time of Birth (TS) <b>optional </b>
058     * <li>PID-8: Administrative Sex (IS) <b>optional </b>
059     * <li>PID-9: Patient Alias (XPN) <b>optional repeating</b>
060     * <li>PID-10: Race (CE) <b>optional repeating</b>
061     * <li>PID-11: Patient Address (XAD) <b>optional repeating</b>
062     * <li>PID-12: County Code (IS) <b>optional </b>
063     * <li>PID-13: Phone Number - Home (XTN) <b>optional repeating</b>
064     * <li>PID-14: Phone Number - Business (XTN) <b>optional repeating</b>
065     * <li>PID-15: Primary Language (CE) <b>optional </b>
066     * <li>PID-16: Marital Status (CE) <b>optional </b>
067     * <li>PID-17: Religion (CE) <b>optional </b>
068     * <li>PID-18: Patient Account Number (CX) <b>optional </b>
069     * <li>PID-19: SSN Number - Patient (ST) <b>optional </b>
070     * <li>PID-20: Driver's License Number - Patient (DLN) <b>optional </b>
071     * <li>PID-21: Mother's Identifier (CX) <b>optional repeating</b>
072     * <li>PID-22: Ethnic Group (CE) <b>optional repeating</b>
073     * <li>PID-23: Birth Place (ST) <b>optional </b>
074     * <li>PID-24: Multiple Birth Indicator (ID) <b>optional </b>
075     * <li>PID-25: Birth Order (NM) <b>optional </b>
076     * <li>PID-26: Citizenship (CE) <b>optional repeating</b>
077     * <li>PID-27: Veterans Military Status (CE) <b>optional </b>
078     * <li>PID-28: Nationality (CE) <b>optional </b>
079     * <li>PID-29: Patient Death Date and Time (TS) <b>optional </b>
080     * <li>PID-30: Patient Death Indicator (ID) <b>optional </b>
081     * <li>PID-31: Identity Unknown Indicator (ID) <b>optional </b>
082     * <li>PID-32: Identity Reliability Code (IS) <b>optional repeating</b>
083     * <li>PID-33: Last Update Date/Time (TS) <b>optional </b>
084     * <li>PID-34: Last Update Facility (HD) <b>optional </b>
085     * <li>PID-35: Species Code (CE) <b>optional </b>
086     * <li>PID-36: Breed Code (CE) <b>optional </b>
087     * <li>PID-37: Strain (ST) <b>optional </b>
088     * <li>PID-38: Production Class Code (CE) <b>optional </b>
089     * <li>PID-39: Tribal Citizenship (CWE) <b>optional repeating</b>
090 * </ul>
091 */
092@SuppressWarnings("unused")
093public class PID extends AbstractSegment {
094
095    /** 
096     * Creates a new PID segment
097     */
098    public PID(Group parent, ModelClassFactory factory) {
099       super(parent, factory);
100       init(factory);
101    }
102
103    private void init(ModelClassFactory factory) {
104       try {
105                                  this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - PID");
106                                  this.add(CX.class, false, 1, 20, new Object[]{ getMessage() }, "Patient ID");
107                                  this.add(CX.class, true, 0, 250, new Object[]{ getMessage() }, "Patient Identifier List");
108                                  this.add(CX.class, false, 0, 20, new Object[]{ getMessage() }, "Alternate Patient ID - PID");
109                                  this.add(XPN.class, true, 0, 250, new Object[]{ getMessage() }, "Patient Name");
110                                  this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Mother's Maiden Name");
111                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of Birth");
112                                              this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Administrative Sex");
113                                  this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Patient Alias");
114                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Race");
115                                  this.add(XAD.class, false, 0, 250, new Object[]{ getMessage() }, "Patient Address");
116                                              this.add(IS.class, false, 1, 4, new Object[]{ getMessage(), new Integer(289) }, "County Code");
117                                  this.add(XTN.class, false, 0, 250, new Object[]{ getMessage() }, "Phone Number - Home");
118                                  this.add(XTN.class, false, 0, 250, new Object[]{ getMessage() }, "Phone Number - Business");
119                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Primary Language");
120                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Marital Status");
121                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Religion");
122                                  this.add(CX.class, false, 1, 250, new Object[]{ getMessage() }, "Patient Account Number");
123                                  this.add(ST.class, false, 1, 16, new Object[]{ getMessage() }, "SSN Number - Patient");
124                                  this.add(DLN.class, false, 1, 25, new Object[]{ getMessage() }, "Driver's License Number - Patient");
125                                  this.add(CX.class, false, 0, 250, new Object[]{ getMessage() }, "Mother's Identifier");
126                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Ethnic Group");
127                                  this.add(ST.class, false, 1, 250, new Object[]{ getMessage() }, "Birth Place");
128                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Multiple Birth Indicator");
129                                  this.add(NM.class, false, 1, 2, new Object[]{ getMessage() }, "Birth Order");
130                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Citizenship");
131                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Veterans Military Status");
132                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Nationality");
133                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Patient Death Date and Time");
134                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Patient Death Indicator");
135                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Identity Unknown Indicator");
136                                              this.add(IS.class, false, 0, 20, new Object[]{ getMessage(), new Integer(445) }, "Identity Reliability Code");
137                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Last Update Date/Time");
138                                  this.add(HD.class, false, 1, 241, new Object[]{ getMessage() }, "Last Update Facility");
139                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Species Code");
140                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Breed Code");
141                                  this.add(ST.class, false, 1, 80, new Object[]{ getMessage() }, "Strain");
142                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Production Class Code");
143                                  this.add(CWE.class, false, 0, 250, new Object[]{ getMessage() }, "Tribal Citizenship");
144       } catch(HL7Exception e) {
145          log.error("Unexpected error creating PID - this is probably a bug in the source code generator.", e);
146       }
147    }
148
149
150
151    /**
152     * Returns
153     * PID-1: "Set ID - PID" - creates it if necessary
154     */
155    public SI getSetIDPID() { 
156                SI retVal = this.getTypedField(1, 0);
157                return retVal;
158    }
159    
160    /**
161     * Returns
162     * PID-1: "Set ID - PID" - creates it if necessary
163     */
164    public SI getPid1_SetIDPID() { 
165                SI retVal = this.getTypedField(1, 0);
166                return retVal;
167    }
168
169
170
171    /**
172     * Returns
173     * PID-2: "Patient ID" - creates it if necessary
174     */
175    public CX getPatientID() { 
176                CX retVal = this.getTypedField(2, 0);
177                return retVal;
178    }
179    
180    /**
181     * Returns
182     * PID-2: "Patient ID" - creates it if necessary
183     */
184    public CX getPid2_PatientID() { 
185                CX retVal = this.getTypedField(2, 0);
186                return retVal;
187    }
188
189
190    /**
191     * Returns all repetitions of Patient Identifier List (PID-3).
192     */
193    public CX[] getPatientIdentifierList() {
194        CX[] retVal = this.getTypedField(3, new CX[0]);
195        return retVal;
196    }
197
198
199    /**
200     * Returns all repetitions of Patient Identifier List (PID-3).
201     */
202    public CX[] getPid3_PatientIdentifierList() {
203        CX[] retVal = this.getTypedField(3, new CX[0]);
204        return retVal;
205    }
206
207
208    /**
209     * Returns a count of the current number of repetitions of Patient Identifier List (PID-3).
210     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
211     * it will return zero.
212     */
213    public int getPatientIdentifierListReps() {
214        return this.getReps(3);
215    }
216
217
218    /**
219     * Returns a specific repetition of
220     * PID-3: "Patient Identifier List" - creates it if necessary
221     *
222     * @param rep The repetition index (0-indexed)
223     */
224    public CX getPatientIdentifierList(int rep) { 
225                CX retVal = this.getTypedField(3, rep);
226                return retVal;
227    }
228
229    /**
230     * Returns a specific repetition of
231     * PID-3: "Patient Identifier List" - creates it if necessary
232     *
233     * @param rep The repetition index (0-indexed)
234     */
235    public CX getPid3_PatientIdentifierList(int rep) { 
236                CX retVal = this.getTypedField(3, rep);
237                return retVal;
238    }
239
240    /**
241     * Returns a count of the current number of repetitions of Patient Identifier List (PID-3).
242     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
243     * it will return zero.
244     */
245    public int getPid3_PatientIdentifierListReps() {
246        return this.getReps(3);
247    }
248
249
250    /**
251     * Inserts a repetition of
252     * PID-3: "Patient Identifier List" at a specific index
253     *
254     * @param rep The repetition index (0-indexed)
255     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
256     */
257    public CX insertPatientIdentifierList(int rep) throws HL7Exception { 
258        return (CX) super.insertRepetition(3, rep);
259    }
260
261
262    /**
263     * Inserts a repetition of
264     * PID-3: "Patient Identifier List" at a specific index
265     *
266     * @param rep The repetition index (0-indexed)
267     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
268     */
269    public CX insertPid3_PatientIdentifierList(int rep) throws HL7Exception { 
270        return (CX) super.insertRepetition(3, rep);
271    }
272
273
274    /**
275     * Removes a repetition of
276     * PID-3: "Patient Identifier List" at a specific index
277     *
278     * @param rep The repetition index (0-indexed)
279     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
280     */
281    public CX removePatientIdentifierList(int rep) throws HL7Exception { 
282        return (CX) super.removeRepetition(3, rep);
283    }
284
285
286    /**
287     * Removes a repetition of
288     * PID-3: "Patient Identifier List" at a specific index
289     *
290     * @param rep The repetition index (0-indexed)
291     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
292     */
293    public CX removePid3_PatientIdentifierList(int rep) throws HL7Exception { 
294        return (CX) super.removeRepetition(3, rep);
295    }
296
297
298
299    /**
300     * Returns all repetitions of Alternate Patient ID - PID (PID-4).
301     */
302    public CX[] getAlternatePatientIDPID() {
303        CX[] retVal = this.getTypedField(4, new CX[0]);
304        return retVal;
305    }
306
307
308    /**
309     * Returns all repetitions of Alternate Patient ID - PID (PID-4).
310     */
311    public CX[] getPid4_AlternatePatientIDPID() {
312        CX[] retVal = this.getTypedField(4, new CX[0]);
313        return retVal;
314    }
315
316
317    /**
318     * Returns a count of the current number of repetitions of Alternate Patient ID - PID (PID-4).
319     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
320     * it will return zero.
321     */
322    public int getAlternatePatientIDPIDReps() {
323        return this.getReps(4);
324    }
325
326
327    /**
328     * Returns a specific repetition of
329     * PID-4: "Alternate Patient ID - PID" - creates it if necessary
330     *
331     * @param rep The repetition index (0-indexed)
332     */
333    public CX getAlternatePatientIDPID(int rep) { 
334                CX retVal = this.getTypedField(4, rep);
335                return retVal;
336    }
337
338    /**
339     * Returns a specific repetition of
340     * PID-4: "Alternate Patient ID - PID" - creates it if necessary
341     *
342     * @param rep The repetition index (0-indexed)
343     */
344    public CX getPid4_AlternatePatientIDPID(int rep) { 
345                CX retVal = this.getTypedField(4, rep);
346                return retVal;
347    }
348
349    /**
350     * Returns a count of the current number of repetitions of Alternate Patient ID - PID (PID-4).
351     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
352     * it will return zero.
353     */
354    public int getPid4_AlternatePatientIDPIDReps() {
355        return this.getReps(4);
356    }
357
358
359    /**
360     * Inserts a repetition of
361     * PID-4: "Alternate Patient ID - PID" at a specific index
362     *
363     * @param rep The repetition index (0-indexed)
364     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
365     */
366    public CX insertAlternatePatientIDPID(int rep) throws HL7Exception { 
367        return (CX) super.insertRepetition(4, rep);
368    }
369
370
371    /**
372     * Inserts a repetition of
373     * PID-4: "Alternate Patient ID - PID" at a specific index
374     *
375     * @param rep The repetition index (0-indexed)
376     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
377     */
378    public CX insertPid4_AlternatePatientIDPID(int rep) throws HL7Exception { 
379        return (CX) super.insertRepetition(4, rep);
380    }
381
382
383    /**
384     * Removes a repetition of
385     * PID-4: "Alternate Patient ID - PID" at a specific index
386     *
387     * @param rep The repetition index (0-indexed)
388     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
389     */
390    public CX removeAlternatePatientIDPID(int rep) throws HL7Exception { 
391        return (CX) super.removeRepetition(4, rep);
392    }
393
394
395    /**
396     * Removes a repetition of
397     * PID-4: "Alternate Patient ID - PID" at a specific index
398     *
399     * @param rep The repetition index (0-indexed)
400     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
401     */
402    public CX removePid4_AlternatePatientIDPID(int rep) throws HL7Exception { 
403        return (CX) super.removeRepetition(4, rep);
404    }
405
406
407
408    /**
409     * Returns all repetitions of Patient Name (PID-5).
410     */
411    public XPN[] getPatientName() {
412        XPN[] retVal = this.getTypedField(5, new XPN[0]);
413        return retVal;
414    }
415
416
417    /**
418     * Returns all repetitions of Patient Name (PID-5).
419     */
420    public XPN[] getPid5_PatientName() {
421        XPN[] retVal = this.getTypedField(5, new XPN[0]);
422        return retVal;
423    }
424
425
426    /**
427     * Returns a count of the current number of repetitions of Patient Name (PID-5).
428     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
429     * it will return zero.
430     */
431    public int getPatientNameReps() {
432        return this.getReps(5);
433    }
434
435
436    /**
437     * Returns a specific repetition of
438     * PID-5: "Patient Name" - creates it if necessary
439     *
440     * @param rep The repetition index (0-indexed)
441     */
442    public XPN getPatientName(int rep) { 
443                XPN retVal = this.getTypedField(5, rep);
444                return retVal;
445    }
446
447    /**
448     * Returns a specific repetition of
449     * PID-5: "Patient Name" - creates it if necessary
450     *
451     * @param rep The repetition index (0-indexed)
452     */
453    public XPN getPid5_PatientName(int rep) { 
454                XPN retVal = this.getTypedField(5, rep);
455                return retVal;
456    }
457
458    /**
459     * Returns a count of the current number of repetitions of Patient Name (PID-5).
460     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
461     * it will return zero.
462     */
463    public int getPid5_PatientNameReps() {
464        return this.getReps(5);
465    }
466
467
468    /**
469     * Inserts a repetition of
470     * PID-5: "Patient Name" 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 XPN insertPatientName(int rep) throws HL7Exception { 
476        return (XPN) super.insertRepetition(5, rep);
477    }
478
479
480    /**
481     * Inserts a repetition of
482     * PID-5: "Patient Name" 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 XPN insertPid5_PatientName(int rep) throws HL7Exception { 
488        return (XPN) super.insertRepetition(5, rep);
489    }
490
491
492    /**
493     * Removes a repetition of
494     * PID-5: "Patient Name" 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 XPN removePatientName(int rep) throws HL7Exception { 
500        return (XPN) super.removeRepetition(5, rep);
501    }
502
503
504    /**
505     * Removes a repetition of
506     * PID-5: "Patient Name" at a specific index
507     *
508     * @param rep The repetition index (0-indexed)
509     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
510     */
511    public XPN removePid5_PatientName(int rep) throws HL7Exception { 
512        return (XPN) super.removeRepetition(5, rep);
513    }
514
515
516
517    /**
518     * Returns all repetitions of Mother's Maiden Name (PID-6).
519     */
520    public XPN[] getMotherSMaidenName() {
521        XPN[] retVal = this.getTypedField(6, new XPN[0]);
522        return retVal;
523    }
524
525
526    /**
527     * Returns all repetitions of Mother's Maiden Name (PID-6).
528     */
529    public XPN[] getPid6_MotherSMaidenName() {
530        XPN[] retVal = this.getTypedField(6, new XPN[0]);
531        return retVal;
532    }
533
534
535    /**
536     * Returns a count of the current number of repetitions of Mother's Maiden Name (PID-6).
537     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
538     * it will return zero.
539     */
540    public int getMotherSMaidenNameReps() {
541        return this.getReps(6);
542    }
543
544
545    /**
546     * Returns a specific repetition of
547     * PID-6: "Mother's Maiden Name" - creates it if necessary
548     *
549     * @param rep The repetition index (0-indexed)
550     */
551    public XPN getMotherSMaidenName(int rep) { 
552                XPN retVal = this.getTypedField(6, rep);
553                return retVal;
554    }
555
556    /**
557     * Returns a specific repetition of
558     * PID-6: "Mother's Maiden Name" - creates it if necessary
559     *
560     * @param rep The repetition index (0-indexed)
561     */
562    public XPN getPid6_MotherSMaidenName(int rep) { 
563                XPN retVal = this.getTypedField(6, rep);
564                return retVal;
565    }
566
567    /**
568     * Returns a count of the current number of repetitions of Mother's Maiden Name (PID-6).
569     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
570     * it will return zero.
571     */
572    public int getPid6_MotherSMaidenNameReps() {
573        return this.getReps(6);
574    }
575
576
577    /**
578     * Inserts a repetition of
579     * PID-6: "Mother's Maiden Name" 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 XPN insertMotherSMaidenName(int rep) throws HL7Exception { 
585        return (XPN) super.insertRepetition(6, rep);
586    }
587
588
589    /**
590     * Inserts a repetition of
591     * PID-6: "Mother's Maiden Name" 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 XPN insertPid6_MotherSMaidenName(int rep) throws HL7Exception { 
597        return (XPN) super.insertRepetition(6, rep);
598    }
599
600
601    /**
602     * Removes a repetition of
603     * PID-6: "Mother's Maiden Name" at a specific index
604     *
605     * @param rep The repetition index (0-indexed)
606     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
607     */
608    public XPN removeMotherSMaidenName(int rep) throws HL7Exception { 
609        return (XPN) super.removeRepetition(6, rep);
610    }
611
612
613    /**
614     * Removes a repetition of
615     * PID-6: "Mother's Maiden Name" at a specific index
616     *
617     * @param rep The repetition index (0-indexed)
618     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
619     */
620    public XPN removePid6_MotherSMaidenName(int rep) throws HL7Exception { 
621        return (XPN) super.removeRepetition(6, rep);
622    }
623
624
625
626
627    /**
628     * Returns
629     * PID-7: "Date/Time of Birth" - creates it if necessary
630     */
631    public TS getDateTimeOfBirth() { 
632                TS retVal = this.getTypedField(7, 0);
633                return retVal;
634    }
635    
636    /**
637     * Returns
638     * PID-7: "Date/Time of Birth" - creates it if necessary
639     */
640    public TS getPid7_DateTimeOfBirth() { 
641                TS retVal = this.getTypedField(7, 0);
642                return retVal;
643    }
644
645
646
647    /**
648     * Returns
649     * PID-8: "Administrative Sex" - creates it if necessary
650     */
651    public IS getAdministrativeSex() { 
652                IS retVal = this.getTypedField(8, 0);
653                return retVal;
654    }
655    
656    /**
657     * Returns
658     * PID-8: "Administrative Sex" - creates it if necessary
659     */
660    public IS getPid8_AdministrativeSex() { 
661                IS retVal = this.getTypedField(8, 0);
662                return retVal;
663    }
664
665
666    /**
667     * Returns all repetitions of Patient Alias (PID-9).
668     */
669    public XPN[] getPatientAlias() {
670        XPN[] retVal = this.getTypedField(9, new XPN[0]);
671        return retVal;
672    }
673
674
675    /**
676     * Returns all repetitions of Patient Alias (PID-9).
677     */
678    public XPN[] getPid9_PatientAlias() {
679        XPN[] retVal = this.getTypedField(9, new XPN[0]);
680        return retVal;
681    }
682
683
684    /**
685     * Returns a count of the current number of repetitions of Patient Alias (PID-9).
686     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
687     * it will return zero.
688     */
689    public int getPatientAliasReps() {
690        return this.getReps(9);
691    }
692
693
694    /**
695     * Returns a specific repetition of
696     * PID-9: "Patient Alias" - creates it if necessary
697     *
698     * @param rep The repetition index (0-indexed)
699     */
700    public XPN getPatientAlias(int rep) { 
701                XPN retVal = this.getTypedField(9, rep);
702                return retVal;
703    }
704
705    /**
706     * Returns a specific repetition of
707     * PID-9: "Patient Alias" - creates it if necessary
708     *
709     * @param rep The repetition index (0-indexed)
710     */
711    public XPN getPid9_PatientAlias(int rep) { 
712                XPN retVal = this.getTypedField(9, rep);
713                return retVal;
714    }
715
716    /**
717     * Returns a count of the current number of repetitions of Patient Alias (PID-9).
718     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
719     * it will return zero.
720     */
721    public int getPid9_PatientAliasReps() {
722        return this.getReps(9);
723    }
724
725
726    /**
727     * Inserts a repetition of
728     * PID-9: "Patient Alias" at a specific index
729     *
730     * @param rep The repetition index (0-indexed)
731     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
732     */
733    public XPN insertPatientAlias(int rep) throws HL7Exception { 
734        return (XPN) super.insertRepetition(9, rep);
735    }
736
737
738    /**
739     * Inserts a repetition of
740     * PID-9: "Patient Alias" at a specific index
741     *
742     * @param rep The repetition index (0-indexed)
743     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
744     */
745    public XPN insertPid9_PatientAlias(int rep) throws HL7Exception { 
746        return (XPN) super.insertRepetition(9, rep);
747    }
748
749
750    /**
751     * Removes a repetition of
752     * PID-9: "Patient Alias" at a specific index
753     *
754     * @param rep The repetition index (0-indexed)
755     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
756     */
757    public XPN removePatientAlias(int rep) throws HL7Exception { 
758        return (XPN) super.removeRepetition(9, rep);
759    }
760
761
762    /**
763     * Removes a repetition of
764     * PID-9: "Patient Alias" at a specific index
765     *
766     * @param rep The repetition index (0-indexed)
767     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
768     */
769    public XPN removePid9_PatientAlias(int rep) throws HL7Exception { 
770        return (XPN) super.removeRepetition(9, rep);
771    }
772
773
774
775    /**
776     * Returns all repetitions of Race (PID-10).
777     */
778    public CE[] getRace() {
779        CE[] retVal = this.getTypedField(10, new CE[0]);
780        return retVal;
781    }
782
783
784    /**
785     * Returns all repetitions of Race (PID-10).
786     */
787    public CE[] getPid10_Race() {
788        CE[] retVal = this.getTypedField(10, new CE[0]);
789        return retVal;
790    }
791
792
793    /**
794     * Returns a count of the current number of repetitions of Race (PID-10).
795     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
796     * it will return zero.
797     */
798    public int getRaceReps() {
799        return this.getReps(10);
800    }
801
802
803    /**
804     * Returns a specific repetition of
805     * PID-10: "Race" - creates it if necessary
806     *
807     * @param rep The repetition index (0-indexed)
808     */
809    public CE getRace(int rep) { 
810                CE retVal = this.getTypedField(10, rep);
811                return retVal;
812    }
813
814    /**
815     * Returns a specific repetition of
816     * PID-10: "Race" - creates it if necessary
817     *
818     * @param rep The repetition index (0-indexed)
819     */
820    public CE getPid10_Race(int rep) { 
821                CE retVal = this.getTypedField(10, rep);
822                return retVal;
823    }
824
825    /**
826     * Returns a count of the current number of repetitions of Race (PID-10).
827     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
828     * it will return zero.
829     */
830    public int getPid10_RaceReps() {
831        return this.getReps(10);
832    }
833
834
835    /**
836     * Inserts a repetition of
837     * PID-10: "Race" at a specific index
838     *
839     * @param rep The repetition index (0-indexed)
840     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
841     */
842    public CE insertRace(int rep) throws HL7Exception { 
843        return (CE) super.insertRepetition(10, rep);
844    }
845
846
847    /**
848     * Inserts a repetition of
849     * PID-10: "Race" at a specific index
850     *
851     * @param rep The repetition index (0-indexed)
852     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
853     */
854    public CE insertPid10_Race(int rep) throws HL7Exception { 
855        return (CE) super.insertRepetition(10, rep);
856    }
857
858
859    /**
860     * Removes a repetition of
861     * PID-10: "Race" at a specific index
862     *
863     * @param rep The repetition index (0-indexed)
864     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
865     */
866    public CE removeRace(int rep) throws HL7Exception { 
867        return (CE) super.removeRepetition(10, rep);
868    }
869
870
871    /**
872     * Removes a repetition of
873     * PID-10: "Race" at a specific index
874     *
875     * @param rep The repetition index (0-indexed)
876     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
877     */
878    public CE removePid10_Race(int rep) throws HL7Exception { 
879        return (CE) super.removeRepetition(10, rep);
880    }
881
882
883
884    /**
885     * Returns all repetitions of Patient Address (PID-11).
886     */
887    public XAD[] getPatientAddress() {
888        XAD[] retVal = this.getTypedField(11, new XAD[0]);
889        return retVal;
890    }
891
892
893    /**
894     * Returns all repetitions of Patient Address (PID-11).
895     */
896    public XAD[] getPid11_PatientAddress() {
897        XAD[] retVal = this.getTypedField(11, new XAD[0]);
898        return retVal;
899    }
900
901
902    /**
903     * Returns a count of the current number of repetitions of Patient Address (PID-11).
904     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
905     * it will return zero.
906     */
907    public int getPatientAddressReps() {
908        return this.getReps(11);
909    }
910
911
912    /**
913     * Returns a specific repetition of
914     * PID-11: "Patient Address" - creates it if necessary
915     *
916     * @param rep The repetition index (0-indexed)
917     */
918    public XAD getPatientAddress(int rep) { 
919                XAD retVal = this.getTypedField(11, rep);
920                return retVal;
921    }
922
923    /**
924     * Returns a specific repetition of
925     * PID-11: "Patient Address" - creates it if necessary
926     *
927     * @param rep The repetition index (0-indexed)
928     */
929    public XAD getPid11_PatientAddress(int rep) { 
930                XAD retVal = this.getTypedField(11, rep);
931                return retVal;
932    }
933
934    /**
935     * Returns a count of the current number of repetitions of Patient Address (PID-11).
936     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
937     * it will return zero.
938     */
939    public int getPid11_PatientAddressReps() {
940        return this.getReps(11);
941    }
942
943
944    /**
945     * Inserts a repetition of
946     * PID-11: "Patient Address" at a specific index
947     *
948     * @param rep The repetition index (0-indexed)
949     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
950     */
951    public XAD insertPatientAddress(int rep) throws HL7Exception { 
952        return (XAD) super.insertRepetition(11, rep);
953    }
954
955
956    /**
957     * Inserts a repetition of
958     * PID-11: "Patient Address" at a specific index
959     *
960     * @param rep The repetition index (0-indexed)
961     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
962     */
963    public XAD insertPid11_PatientAddress(int rep) throws HL7Exception { 
964        return (XAD) super.insertRepetition(11, rep);
965    }
966
967
968    /**
969     * Removes a repetition of
970     * PID-11: "Patient Address" at a specific index
971     *
972     * @param rep The repetition index (0-indexed)
973     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
974     */
975    public XAD removePatientAddress(int rep) throws HL7Exception { 
976        return (XAD) super.removeRepetition(11, rep);
977    }
978
979
980    /**
981     * Removes a repetition of
982     * PID-11: "Patient Address" 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 XAD removePid11_PatientAddress(int rep) throws HL7Exception { 
988        return (XAD) super.removeRepetition(11, rep);
989    }
990
991
992
993
994    /**
995     * Returns
996     * PID-12: "County Code" - creates it if necessary
997     */
998    public IS getCountyCode() { 
999                IS retVal = this.getTypedField(12, 0);
1000                return retVal;
1001    }
1002    
1003    /**
1004     * Returns
1005     * PID-12: "County Code" - creates it if necessary
1006     */
1007    public IS getPid12_CountyCode() { 
1008                IS retVal = this.getTypedField(12, 0);
1009                return retVal;
1010    }
1011
1012
1013    /**
1014     * Returns all repetitions of Phone Number - Home (PID-13).
1015     */
1016    public XTN[] getPhoneNumberHome() {
1017        XTN[] retVal = this.getTypedField(13, new XTN[0]);
1018        return retVal;
1019    }
1020
1021
1022    /**
1023     * Returns all repetitions of Phone Number - Home (PID-13).
1024     */
1025    public XTN[] getPid13_PhoneNumberHome() {
1026        XTN[] retVal = this.getTypedField(13, new XTN[0]);
1027        return retVal;
1028    }
1029
1030
1031    /**
1032     * Returns a count of the current number of repetitions of Phone Number - Home (PID-13).
1033     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1034     * it will return zero.
1035     */
1036    public int getPhoneNumberHomeReps() {
1037        return this.getReps(13);
1038    }
1039
1040
1041    /**
1042     * Returns a specific repetition of
1043     * PID-13: "Phone Number - Home" - creates it if necessary
1044     *
1045     * @param rep The repetition index (0-indexed)
1046     */
1047    public XTN getPhoneNumberHome(int rep) { 
1048                XTN retVal = this.getTypedField(13, rep);
1049                return retVal;
1050    }
1051
1052    /**
1053     * Returns a specific repetition of
1054     * PID-13: "Phone Number - Home" - creates it if necessary
1055     *
1056     * @param rep The repetition index (0-indexed)
1057     */
1058    public XTN getPid13_PhoneNumberHome(int rep) { 
1059                XTN retVal = this.getTypedField(13, rep);
1060                return retVal;
1061    }
1062
1063    /**
1064     * Returns a count of the current number of repetitions of Phone Number - Home (PID-13).
1065     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1066     * it will return zero.
1067     */
1068    public int getPid13_PhoneNumberHomeReps() {
1069        return this.getReps(13);
1070    }
1071
1072
1073    /**
1074     * Inserts a repetition of
1075     * PID-13: "Phone Number - Home" at a specific index
1076     *
1077     * @param rep The repetition index (0-indexed)
1078     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1079     */
1080    public XTN insertPhoneNumberHome(int rep) throws HL7Exception { 
1081        return (XTN) super.insertRepetition(13, rep);
1082    }
1083
1084
1085    /**
1086     * Inserts a repetition of
1087     * PID-13: "Phone Number - Home" at a specific index
1088     *
1089     * @param rep The repetition index (0-indexed)
1090     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1091     */
1092    public XTN insertPid13_PhoneNumberHome(int rep) throws HL7Exception { 
1093        return (XTN) super.insertRepetition(13, rep);
1094    }
1095
1096
1097    /**
1098     * Removes a repetition of
1099     * PID-13: "Phone Number - Home" at a specific index
1100     *
1101     * @param rep The repetition index (0-indexed)
1102     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1103     */
1104    public XTN removePhoneNumberHome(int rep) throws HL7Exception { 
1105        return (XTN) super.removeRepetition(13, rep);
1106    }
1107
1108
1109    /**
1110     * Removes a repetition of
1111     * PID-13: "Phone Number - Home" at a specific index
1112     *
1113     * @param rep The repetition index (0-indexed)
1114     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1115     */
1116    public XTN removePid13_PhoneNumberHome(int rep) throws HL7Exception { 
1117        return (XTN) super.removeRepetition(13, rep);
1118    }
1119
1120
1121
1122    /**
1123     * Returns all repetitions of Phone Number - Business (PID-14).
1124     */
1125    public XTN[] getPhoneNumberBusiness() {
1126        XTN[] retVal = this.getTypedField(14, new XTN[0]);
1127        return retVal;
1128    }
1129
1130
1131    /**
1132     * Returns all repetitions of Phone Number - Business (PID-14).
1133     */
1134    public XTN[] getPid14_PhoneNumberBusiness() {
1135        XTN[] retVal = this.getTypedField(14, new XTN[0]);
1136        return retVal;
1137    }
1138
1139
1140    /**
1141     * Returns a count of the current number of repetitions of Phone Number - Business (PID-14).
1142     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1143     * it will return zero.
1144     */
1145    public int getPhoneNumberBusinessReps() {
1146        return this.getReps(14);
1147    }
1148
1149
1150    /**
1151     * Returns a specific repetition of
1152     * PID-14: "Phone Number - Business" - creates it if necessary
1153     *
1154     * @param rep The repetition index (0-indexed)
1155     */
1156    public XTN getPhoneNumberBusiness(int rep) { 
1157                XTN retVal = this.getTypedField(14, rep);
1158                return retVal;
1159    }
1160
1161    /**
1162     * Returns a specific repetition of
1163     * PID-14: "Phone Number - Business" - creates it if necessary
1164     *
1165     * @param rep The repetition index (0-indexed)
1166     */
1167    public XTN getPid14_PhoneNumberBusiness(int rep) { 
1168                XTN retVal = this.getTypedField(14, rep);
1169                return retVal;
1170    }
1171
1172    /**
1173     * Returns a count of the current number of repetitions of Phone Number - Business (PID-14).
1174     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1175     * it will return zero.
1176     */
1177    public int getPid14_PhoneNumberBusinessReps() {
1178        return this.getReps(14);
1179    }
1180
1181
1182    /**
1183     * Inserts a repetition of
1184     * PID-14: "Phone Number - Business" at a specific index
1185     *
1186     * @param rep The repetition index (0-indexed)
1187     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1188     */
1189    public XTN insertPhoneNumberBusiness(int rep) throws HL7Exception { 
1190        return (XTN) super.insertRepetition(14, rep);
1191    }
1192
1193
1194    /**
1195     * Inserts a repetition of
1196     * PID-14: "Phone Number - Business" at a specific index
1197     *
1198     * @param rep The repetition index (0-indexed)
1199     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1200     */
1201    public XTN insertPid14_PhoneNumberBusiness(int rep) throws HL7Exception { 
1202        return (XTN) super.insertRepetition(14, rep);
1203    }
1204
1205
1206    /**
1207     * Removes a repetition of
1208     * PID-14: "Phone Number - Business" at a specific index
1209     *
1210     * @param rep The repetition index (0-indexed)
1211     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1212     */
1213    public XTN removePhoneNumberBusiness(int rep) throws HL7Exception { 
1214        return (XTN) super.removeRepetition(14, rep);
1215    }
1216
1217
1218    /**
1219     * Removes a repetition of
1220     * PID-14: "Phone Number - Business" at a specific index
1221     *
1222     * @param rep The repetition index (0-indexed)
1223     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1224     */
1225    public XTN removePid14_PhoneNumberBusiness(int rep) throws HL7Exception { 
1226        return (XTN) super.removeRepetition(14, rep);
1227    }
1228
1229
1230
1231
1232    /**
1233     * Returns
1234     * PID-15: "Primary Language" - creates it if necessary
1235     */
1236    public CE getPrimaryLanguage() { 
1237                CE retVal = this.getTypedField(15, 0);
1238                return retVal;
1239    }
1240    
1241    /**
1242     * Returns
1243     * PID-15: "Primary Language" - creates it if necessary
1244     */
1245    public CE getPid15_PrimaryLanguage() { 
1246                CE retVal = this.getTypedField(15, 0);
1247                return retVal;
1248    }
1249
1250
1251
1252    /**
1253     * Returns
1254     * PID-16: "Marital Status" - creates it if necessary
1255     */
1256    public CE getMaritalStatus() { 
1257                CE retVal = this.getTypedField(16, 0);
1258                return retVal;
1259    }
1260    
1261    /**
1262     * Returns
1263     * PID-16: "Marital Status" - creates it if necessary
1264     */
1265    public CE getPid16_MaritalStatus() { 
1266                CE retVal = this.getTypedField(16, 0);
1267                return retVal;
1268    }
1269
1270
1271
1272    /**
1273     * Returns
1274     * PID-17: "Religion" - creates it if necessary
1275     */
1276    public CE getReligion() { 
1277                CE retVal = this.getTypedField(17, 0);
1278                return retVal;
1279    }
1280    
1281    /**
1282     * Returns
1283     * PID-17: "Religion" - creates it if necessary
1284     */
1285    public CE getPid17_Religion() { 
1286                CE retVal = this.getTypedField(17, 0);
1287                return retVal;
1288    }
1289
1290
1291
1292    /**
1293     * Returns
1294     * PID-18: "Patient Account Number" - creates it if necessary
1295     */
1296    public CX getPatientAccountNumber() { 
1297                CX retVal = this.getTypedField(18, 0);
1298                return retVal;
1299    }
1300    
1301    /**
1302     * Returns
1303     * PID-18: "Patient Account Number" - creates it if necessary
1304     */
1305    public CX getPid18_PatientAccountNumber() { 
1306                CX retVal = this.getTypedField(18, 0);
1307                return retVal;
1308    }
1309
1310
1311
1312    /**
1313     * Returns
1314     * PID-19: "SSN Number - Patient" - creates it if necessary
1315     */
1316    public ST getSSNNumberPatient() { 
1317                ST retVal = this.getTypedField(19, 0);
1318                return retVal;
1319    }
1320    
1321    /**
1322     * Returns
1323     * PID-19: "SSN Number - Patient" - creates it if necessary
1324     */
1325    public ST getPid19_SSNNumberPatient() { 
1326                ST retVal = this.getTypedField(19, 0);
1327                return retVal;
1328    }
1329
1330
1331
1332    /**
1333     * Returns
1334     * PID-20: "Driver's License Number - Patient" - creates it if necessary
1335     */
1336    public DLN getDriverSLicenseNumberPatient() { 
1337                DLN retVal = this.getTypedField(20, 0);
1338                return retVal;
1339    }
1340    
1341    /**
1342     * Returns
1343     * PID-20: "Driver's License Number - Patient" - creates it if necessary
1344     */
1345    public DLN getPid20_DriverSLicenseNumberPatient() { 
1346                DLN retVal = this.getTypedField(20, 0);
1347                return retVal;
1348    }
1349
1350
1351    /**
1352     * Returns all repetitions of Mother's Identifier (PID-21).
1353     */
1354    public CX[] getMotherSIdentifier() {
1355        CX[] retVal = this.getTypedField(21, new CX[0]);
1356        return retVal;
1357    }
1358
1359
1360    /**
1361     * Returns all repetitions of Mother's Identifier (PID-21).
1362     */
1363    public CX[] getPid21_MotherSIdentifier() {
1364        CX[] retVal = this.getTypedField(21, new CX[0]);
1365        return retVal;
1366    }
1367
1368
1369    /**
1370     * Returns a count of the current number of repetitions of Mother's Identifier (PID-21).
1371     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1372     * it will return zero.
1373     */
1374    public int getMotherSIdentifierReps() {
1375        return this.getReps(21);
1376    }
1377
1378
1379    /**
1380     * Returns a specific repetition of
1381     * PID-21: "Mother's Identifier" - creates it if necessary
1382     *
1383     * @param rep The repetition index (0-indexed)
1384     */
1385    public CX getMotherSIdentifier(int rep) { 
1386                CX retVal = this.getTypedField(21, rep);
1387                return retVal;
1388    }
1389
1390    /**
1391     * Returns a specific repetition of
1392     * PID-21: "Mother's Identifier" - creates it if necessary
1393     *
1394     * @param rep The repetition index (0-indexed)
1395     */
1396    public CX getPid21_MotherSIdentifier(int rep) { 
1397                CX retVal = this.getTypedField(21, rep);
1398                return retVal;
1399    }
1400
1401    /**
1402     * Returns a count of the current number of repetitions of Mother's Identifier (PID-21).
1403     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1404     * it will return zero.
1405     */
1406    public int getPid21_MotherSIdentifierReps() {
1407        return this.getReps(21);
1408    }
1409
1410
1411    /**
1412     * Inserts a repetition of
1413     * PID-21: "Mother's Identifier" at a specific index
1414     *
1415     * @param rep The repetition index (0-indexed)
1416     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1417     */
1418    public CX insertMotherSIdentifier(int rep) throws HL7Exception { 
1419        return (CX) super.insertRepetition(21, rep);
1420    }
1421
1422
1423    /**
1424     * Inserts a repetition of
1425     * PID-21: "Mother's Identifier" at a specific index
1426     *
1427     * @param rep The repetition index (0-indexed)
1428     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1429     */
1430    public CX insertPid21_MotherSIdentifier(int rep) throws HL7Exception { 
1431        return (CX) super.insertRepetition(21, rep);
1432    }
1433
1434
1435    /**
1436     * Removes a repetition of
1437     * PID-21: "Mother's Identifier" at a specific index
1438     *
1439     * @param rep The repetition index (0-indexed)
1440     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1441     */
1442    public CX removeMotherSIdentifier(int rep) throws HL7Exception { 
1443        return (CX) super.removeRepetition(21, rep);
1444    }
1445
1446
1447    /**
1448     * Removes a repetition of
1449     * PID-21: "Mother's Identifier" at a specific index
1450     *
1451     * @param rep The repetition index (0-indexed)
1452     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1453     */
1454    public CX removePid21_MotherSIdentifier(int rep) throws HL7Exception { 
1455        return (CX) super.removeRepetition(21, rep);
1456    }
1457
1458
1459
1460    /**
1461     * Returns all repetitions of Ethnic Group (PID-22).
1462     */
1463    public CE[] getEthnicGroup() {
1464        CE[] retVal = this.getTypedField(22, new CE[0]);
1465        return retVal;
1466    }
1467
1468
1469    /**
1470     * Returns all repetitions of Ethnic Group (PID-22).
1471     */
1472    public CE[] getPid22_EthnicGroup() {
1473        CE[] retVal = this.getTypedField(22, new CE[0]);
1474        return retVal;
1475    }
1476
1477
1478    /**
1479     * Returns a count of the current number of repetitions of Ethnic Group (PID-22).
1480     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1481     * it will return zero.
1482     */
1483    public int getEthnicGroupReps() {
1484        return this.getReps(22);
1485    }
1486
1487
1488    /**
1489     * Returns a specific repetition of
1490     * PID-22: "Ethnic Group" - creates it if necessary
1491     *
1492     * @param rep The repetition index (0-indexed)
1493     */
1494    public CE getEthnicGroup(int rep) { 
1495                CE retVal = this.getTypedField(22, rep);
1496                return retVal;
1497    }
1498
1499    /**
1500     * Returns a specific repetition of
1501     * PID-22: "Ethnic Group" - creates it if necessary
1502     *
1503     * @param rep The repetition index (0-indexed)
1504     */
1505    public CE getPid22_EthnicGroup(int rep) { 
1506                CE retVal = this.getTypedField(22, rep);
1507                return retVal;
1508    }
1509
1510    /**
1511     * Returns a count of the current number of repetitions of Ethnic Group (PID-22).
1512     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1513     * it will return zero.
1514     */
1515    public int getPid22_EthnicGroupReps() {
1516        return this.getReps(22);
1517    }
1518
1519
1520    /**
1521     * Inserts a repetition of
1522     * PID-22: "Ethnic Group" at a specific index
1523     *
1524     * @param rep The repetition index (0-indexed)
1525     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1526     */
1527    public CE insertEthnicGroup(int rep) throws HL7Exception { 
1528        return (CE) super.insertRepetition(22, rep);
1529    }
1530
1531
1532    /**
1533     * Inserts a repetition of
1534     * PID-22: "Ethnic Group" at a specific index
1535     *
1536     * @param rep The repetition index (0-indexed)
1537     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1538     */
1539    public CE insertPid22_EthnicGroup(int rep) throws HL7Exception { 
1540        return (CE) super.insertRepetition(22, rep);
1541    }
1542
1543
1544    /**
1545     * Removes a repetition of
1546     * PID-22: "Ethnic Group" at a specific index
1547     *
1548     * @param rep The repetition index (0-indexed)
1549     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1550     */
1551    public CE removeEthnicGroup(int rep) throws HL7Exception { 
1552        return (CE) super.removeRepetition(22, rep);
1553    }
1554
1555
1556    /**
1557     * Removes a repetition of
1558     * PID-22: "Ethnic Group" at a specific index
1559     *
1560     * @param rep The repetition index (0-indexed)
1561     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1562     */
1563    public CE removePid22_EthnicGroup(int rep) throws HL7Exception { 
1564        return (CE) super.removeRepetition(22, rep);
1565    }
1566
1567
1568
1569
1570    /**
1571     * Returns
1572     * PID-23: "Birth Place" - creates it if necessary
1573     */
1574    public ST getBirthPlace() { 
1575                ST retVal = this.getTypedField(23, 0);
1576                return retVal;
1577    }
1578    
1579    /**
1580     * Returns
1581     * PID-23: "Birth Place" - creates it if necessary
1582     */
1583    public ST getPid23_BirthPlace() { 
1584                ST retVal = this.getTypedField(23, 0);
1585                return retVal;
1586    }
1587
1588
1589
1590    /**
1591     * Returns
1592     * PID-24: "Multiple Birth Indicator" - creates it if necessary
1593     */
1594    public ID getMultipleBirthIndicator() { 
1595                ID retVal = this.getTypedField(24, 0);
1596                return retVal;
1597    }
1598    
1599    /**
1600     * Returns
1601     * PID-24: "Multiple Birth Indicator" - creates it if necessary
1602     */
1603    public ID getPid24_MultipleBirthIndicator() { 
1604                ID retVal = this.getTypedField(24, 0);
1605                return retVal;
1606    }
1607
1608
1609
1610    /**
1611     * Returns
1612     * PID-25: "Birth Order" - creates it if necessary
1613     */
1614    public NM getBirthOrder() { 
1615                NM retVal = this.getTypedField(25, 0);
1616                return retVal;
1617    }
1618    
1619    /**
1620     * Returns
1621     * PID-25: "Birth Order" - creates it if necessary
1622     */
1623    public NM getPid25_BirthOrder() { 
1624                NM retVal = this.getTypedField(25, 0);
1625                return retVal;
1626    }
1627
1628
1629    /**
1630     * Returns all repetitions of Citizenship (PID-26).
1631     */
1632    public CE[] getCitizenship() {
1633        CE[] retVal = this.getTypedField(26, new CE[0]);
1634        return retVal;
1635    }
1636
1637
1638    /**
1639     * Returns all repetitions of Citizenship (PID-26).
1640     */
1641    public CE[] getPid26_Citizenship() {
1642        CE[] retVal = this.getTypedField(26, new CE[0]);
1643        return retVal;
1644    }
1645
1646
1647    /**
1648     * Returns a count of the current number of repetitions of Citizenship (PID-26).
1649     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1650     * it will return zero.
1651     */
1652    public int getCitizenshipReps() {
1653        return this.getReps(26);
1654    }
1655
1656
1657    /**
1658     * Returns a specific repetition of
1659     * PID-26: "Citizenship" - creates it if necessary
1660     *
1661     * @param rep The repetition index (0-indexed)
1662     */
1663    public CE getCitizenship(int rep) { 
1664                CE retVal = this.getTypedField(26, rep);
1665                return retVal;
1666    }
1667
1668    /**
1669     * Returns a specific repetition of
1670     * PID-26: "Citizenship" - creates it if necessary
1671     *
1672     * @param rep The repetition index (0-indexed)
1673     */
1674    public CE getPid26_Citizenship(int rep) { 
1675                CE retVal = this.getTypedField(26, rep);
1676                return retVal;
1677    }
1678
1679    /**
1680     * Returns a count of the current number of repetitions of Citizenship (PID-26).
1681     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1682     * it will return zero.
1683     */
1684    public int getPid26_CitizenshipReps() {
1685        return this.getReps(26);
1686    }
1687
1688
1689    /**
1690     * Inserts a repetition of
1691     * PID-26: "Citizenship" at a specific index
1692     *
1693     * @param rep The repetition index (0-indexed)
1694     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1695     */
1696    public CE insertCitizenship(int rep) throws HL7Exception { 
1697        return (CE) super.insertRepetition(26, rep);
1698    }
1699
1700
1701    /**
1702     * Inserts a repetition of
1703     * PID-26: "Citizenship" at a specific index
1704     *
1705     * @param rep The repetition index (0-indexed)
1706     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1707     */
1708    public CE insertPid26_Citizenship(int rep) throws HL7Exception { 
1709        return (CE) super.insertRepetition(26, rep);
1710    }
1711
1712
1713    /**
1714     * Removes a repetition of
1715     * PID-26: "Citizenship" at a specific index
1716     *
1717     * @param rep The repetition index (0-indexed)
1718     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1719     */
1720    public CE removeCitizenship(int rep) throws HL7Exception { 
1721        return (CE) super.removeRepetition(26, rep);
1722    }
1723
1724
1725    /**
1726     * Removes a repetition of
1727     * PID-26: "Citizenship" at a specific index
1728     *
1729     * @param rep The repetition index (0-indexed)
1730     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1731     */
1732    public CE removePid26_Citizenship(int rep) throws HL7Exception { 
1733        return (CE) super.removeRepetition(26, rep);
1734    }
1735
1736
1737
1738
1739    /**
1740     * Returns
1741     * PID-27: "Veterans Military Status" - creates it if necessary
1742     */
1743    public CE getVeteransMilitaryStatus() { 
1744                CE retVal = this.getTypedField(27, 0);
1745                return retVal;
1746    }
1747    
1748    /**
1749     * Returns
1750     * PID-27: "Veterans Military Status" - creates it if necessary
1751     */
1752    public CE getPid27_VeteransMilitaryStatus() { 
1753                CE retVal = this.getTypedField(27, 0);
1754                return retVal;
1755    }
1756
1757
1758
1759    /**
1760     * Returns
1761     * PID-28: "Nationality" - creates it if necessary
1762     */
1763    public CE getNationality() { 
1764                CE retVal = this.getTypedField(28, 0);
1765                return retVal;
1766    }
1767    
1768    /**
1769     * Returns
1770     * PID-28: "Nationality" - creates it if necessary
1771     */
1772    public CE getPid28_Nationality() { 
1773                CE retVal = this.getTypedField(28, 0);
1774                return retVal;
1775    }
1776
1777
1778
1779    /**
1780     * Returns
1781     * PID-29: "Patient Death Date and Time" - creates it if necessary
1782     */
1783    public TS getPatientDeathDateAndTime() { 
1784                TS retVal = this.getTypedField(29, 0);
1785                return retVal;
1786    }
1787    
1788    /**
1789     * Returns
1790     * PID-29: "Patient Death Date and Time" - creates it if necessary
1791     */
1792    public TS getPid29_PatientDeathDateAndTime() { 
1793                TS retVal = this.getTypedField(29, 0);
1794                return retVal;
1795    }
1796
1797
1798
1799    /**
1800     * Returns
1801     * PID-30: "Patient Death Indicator" - creates it if necessary
1802     */
1803    public ID getPatientDeathIndicator() { 
1804                ID retVal = this.getTypedField(30, 0);
1805                return retVal;
1806    }
1807    
1808    /**
1809     * Returns
1810     * PID-30: "Patient Death Indicator" - creates it if necessary
1811     */
1812    public ID getPid30_PatientDeathIndicator() { 
1813                ID retVal = this.getTypedField(30, 0);
1814                return retVal;
1815    }
1816
1817
1818
1819    /**
1820     * Returns
1821     * PID-31: "Identity Unknown Indicator" - creates it if necessary
1822     */
1823    public ID getIdentityUnknownIndicator() { 
1824                ID retVal = this.getTypedField(31, 0);
1825                return retVal;
1826    }
1827    
1828    /**
1829     * Returns
1830     * PID-31: "Identity Unknown Indicator" - creates it if necessary
1831     */
1832    public ID getPid31_IdentityUnknownIndicator() { 
1833                ID retVal = this.getTypedField(31, 0);
1834                return retVal;
1835    }
1836
1837
1838    /**
1839     * Returns all repetitions of Identity Reliability Code (PID-32).
1840     */
1841    public IS[] getIdentityReliabilityCode() {
1842        IS[] retVal = this.getTypedField(32, new IS[0]);
1843        return retVal;
1844    }
1845
1846
1847    /**
1848     * Returns all repetitions of Identity Reliability Code (PID-32).
1849     */
1850    public IS[] getPid32_IdentityReliabilityCode() {
1851        IS[] retVal = this.getTypedField(32, new IS[0]);
1852        return retVal;
1853    }
1854
1855
1856    /**
1857     * Returns a count of the current number of repetitions of Identity Reliability Code (PID-32).
1858     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1859     * it will return zero.
1860     */
1861    public int getIdentityReliabilityCodeReps() {
1862        return this.getReps(32);
1863    }
1864
1865
1866    /**
1867     * Returns a specific repetition of
1868     * PID-32: "Identity Reliability Code" - creates it if necessary
1869     *
1870     * @param rep The repetition index (0-indexed)
1871     */
1872    public IS getIdentityReliabilityCode(int rep) { 
1873                IS retVal = this.getTypedField(32, rep);
1874                return retVal;
1875    }
1876
1877    /**
1878     * Returns a specific repetition of
1879     * PID-32: "Identity Reliability Code" - creates it if necessary
1880     *
1881     * @param rep The repetition index (0-indexed)
1882     */
1883    public IS getPid32_IdentityReliabilityCode(int rep) { 
1884                IS retVal = this.getTypedField(32, rep);
1885                return retVal;
1886    }
1887
1888    /**
1889     * Returns a count of the current number of repetitions of Identity Reliability Code (PID-32).
1890     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1891     * it will return zero.
1892     */
1893    public int getPid32_IdentityReliabilityCodeReps() {
1894        return this.getReps(32);
1895    }
1896
1897
1898    /**
1899     * Inserts a repetition of
1900     * PID-32: "Identity Reliability Code" 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 IS insertIdentityReliabilityCode(int rep) throws HL7Exception { 
1906        return (IS) super.insertRepetition(32, rep);
1907    }
1908
1909
1910    /**
1911     * Inserts a repetition of
1912     * PID-32: "Identity Reliability Code" 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 IS insertPid32_IdentityReliabilityCode(int rep) throws HL7Exception { 
1918        return (IS) super.insertRepetition(32, rep);
1919    }
1920
1921
1922    /**
1923     * Removes a repetition of
1924     * PID-32: "Identity Reliability Code" at a specific index
1925     *
1926     * @param rep The repetition index (0-indexed)
1927     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1928     */
1929    public IS removeIdentityReliabilityCode(int rep) throws HL7Exception { 
1930        return (IS) super.removeRepetition(32, rep);
1931    }
1932
1933
1934    /**
1935     * Removes a repetition of
1936     * PID-32: "Identity Reliability Code" at a specific index
1937     *
1938     * @param rep The repetition index (0-indexed)
1939     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1940     */
1941    public IS removePid32_IdentityReliabilityCode(int rep) throws HL7Exception { 
1942        return (IS) super.removeRepetition(32, rep);
1943    }
1944
1945
1946
1947
1948    /**
1949     * Returns
1950     * PID-33: "Last Update Date/Time" - creates it if necessary
1951     */
1952    public TS getLastUpdateDateTime() { 
1953                TS retVal = this.getTypedField(33, 0);
1954                return retVal;
1955    }
1956    
1957    /**
1958     * Returns
1959     * PID-33: "Last Update Date/Time" - creates it if necessary
1960     */
1961    public TS getPid33_LastUpdateDateTime() { 
1962                TS retVal = this.getTypedField(33, 0);
1963                return retVal;
1964    }
1965
1966
1967
1968    /**
1969     * Returns
1970     * PID-34: "Last Update Facility" - creates it if necessary
1971     */
1972    public HD getLastUpdateFacility() { 
1973                HD retVal = this.getTypedField(34, 0);
1974                return retVal;
1975    }
1976    
1977    /**
1978     * Returns
1979     * PID-34: "Last Update Facility" - creates it if necessary
1980     */
1981    public HD getPid34_LastUpdateFacility() { 
1982                HD retVal = this.getTypedField(34, 0);
1983                return retVal;
1984    }
1985
1986
1987
1988    /**
1989     * Returns
1990     * PID-35: "Species Code" - creates it if necessary
1991     */
1992    public CE getSpeciesCode() { 
1993                CE retVal = this.getTypedField(35, 0);
1994                return retVal;
1995    }
1996    
1997    /**
1998     * Returns
1999     * PID-35: "Species Code" - creates it if necessary
2000     */
2001    public CE getPid35_SpeciesCode() { 
2002                CE retVal = this.getTypedField(35, 0);
2003                return retVal;
2004    }
2005
2006
2007
2008    /**
2009     * Returns
2010     * PID-36: "Breed Code" - creates it if necessary
2011     */
2012    public CE getBreedCode() { 
2013                CE retVal = this.getTypedField(36, 0);
2014                return retVal;
2015    }
2016    
2017    /**
2018     * Returns
2019     * PID-36: "Breed Code" - creates it if necessary
2020     */
2021    public CE getPid36_BreedCode() { 
2022                CE retVal = this.getTypedField(36, 0);
2023                return retVal;
2024    }
2025
2026
2027
2028    /**
2029     * Returns
2030     * PID-37: "Strain" - creates it if necessary
2031     */
2032    public ST getStrain() { 
2033                ST retVal = this.getTypedField(37, 0);
2034                return retVal;
2035    }
2036    
2037    /**
2038     * Returns
2039     * PID-37: "Strain" - creates it if necessary
2040     */
2041    public ST getPid37_Strain() { 
2042                ST retVal = this.getTypedField(37, 0);
2043                return retVal;
2044    }
2045
2046
2047
2048    /**
2049     * Returns
2050     * PID-38: "Production Class Code" - creates it if necessary
2051     */
2052    public CE getProductionClassCode() { 
2053                CE retVal = this.getTypedField(38, 0);
2054                return retVal;
2055    }
2056    
2057    /**
2058     * Returns
2059     * PID-38: "Production Class Code" - creates it if necessary
2060     */
2061    public CE getPid38_ProductionClassCode() { 
2062                CE retVal = this.getTypedField(38, 0);
2063                return retVal;
2064    }
2065
2066
2067    /**
2068     * Returns all repetitions of Tribal Citizenship (PID-39).
2069     */
2070    public CWE[] getTribalCitizenship() {
2071        CWE[] retVal = this.getTypedField(39, new CWE[0]);
2072        return retVal;
2073    }
2074
2075
2076    /**
2077     * Returns all repetitions of Tribal Citizenship (PID-39).
2078     */
2079    public CWE[] getPid39_TribalCitizenship() {
2080        CWE[] retVal = this.getTypedField(39, new CWE[0]);
2081        return retVal;
2082    }
2083
2084
2085    /**
2086     * Returns a count of the current number of repetitions of Tribal Citizenship (PID-39).
2087     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2088     * it will return zero.
2089     */
2090    public int getTribalCitizenshipReps() {
2091        return this.getReps(39);
2092    }
2093
2094
2095    /**
2096     * Returns a specific repetition of
2097     * PID-39: "Tribal Citizenship" - creates it if necessary
2098     *
2099     * @param rep The repetition index (0-indexed)
2100     */
2101    public CWE getTribalCitizenship(int rep) { 
2102                CWE retVal = this.getTypedField(39, rep);
2103                return retVal;
2104    }
2105
2106    /**
2107     * Returns a specific repetition of
2108     * PID-39: "Tribal Citizenship" - creates it if necessary
2109     *
2110     * @param rep The repetition index (0-indexed)
2111     */
2112    public CWE getPid39_TribalCitizenship(int rep) { 
2113                CWE retVal = this.getTypedField(39, rep);
2114                return retVal;
2115    }
2116
2117    /**
2118     * Returns a count of the current number of repetitions of Tribal Citizenship (PID-39).
2119     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2120     * it will return zero.
2121     */
2122    public int getPid39_TribalCitizenshipReps() {
2123        return this.getReps(39);
2124    }
2125
2126
2127    /**
2128     * Inserts a repetition of
2129     * PID-39: "Tribal Citizenship" at a specific index
2130     *
2131     * @param rep The repetition index (0-indexed)
2132     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2133     */
2134    public CWE insertTribalCitizenship(int rep) throws HL7Exception { 
2135        return (CWE) super.insertRepetition(39, rep);
2136    }
2137
2138
2139    /**
2140     * Inserts a repetition of
2141     * PID-39: "Tribal Citizenship" at a specific index
2142     *
2143     * @param rep The repetition index (0-indexed)
2144     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2145     */
2146    public CWE insertPid39_TribalCitizenship(int rep) throws HL7Exception { 
2147        return (CWE) super.insertRepetition(39, rep);
2148    }
2149
2150
2151    /**
2152     * Removes a repetition of
2153     * PID-39: "Tribal Citizenship" at a specific index
2154     *
2155     * @param rep The repetition index (0-indexed)
2156     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2157     */
2158    public CWE removeTribalCitizenship(int rep) throws HL7Exception { 
2159        return (CWE) super.removeRepetition(39, rep);
2160    }
2161
2162
2163    /**
2164     * Removes a repetition of
2165     * PID-39: "Tribal Citizenship" at a specific index
2166     *
2167     * @param rep The repetition index (0-indexed)
2168     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2169     */
2170    public CWE removePid39_TribalCitizenship(int rep) throws HL7Exception { 
2171        return (CWE) super.removeRepetition(39, rep);
2172    }
2173
2174
2175
2176
2177
2178
2179    /** {@inheritDoc} */   
2180    protected Type createNewTypeWithoutReflection(int field) {
2181       switch (field) {
2182          case 0: return new SI(getMessage());
2183          case 1: return new CX(getMessage());
2184          case 2: return new CX(getMessage());
2185          case 3: return new CX(getMessage());
2186          case 4: return new XPN(getMessage());
2187          case 5: return new XPN(getMessage());
2188          case 6: return new TS(getMessage());
2189          case 7: return new IS(getMessage(), new Integer( 1 ));
2190          case 8: return new XPN(getMessage());
2191          case 9: return new CE(getMessage());
2192          case 10: return new XAD(getMessage());
2193          case 11: return new IS(getMessage(), new Integer( 289 ));
2194          case 12: return new XTN(getMessage());
2195          case 13: return new XTN(getMessage());
2196          case 14: return new CE(getMessage());
2197          case 15: return new CE(getMessage());
2198          case 16: return new CE(getMessage());
2199          case 17: return new CX(getMessage());
2200          case 18: return new ST(getMessage());
2201          case 19: return new DLN(getMessage());
2202          case 20: return new CX(getMessage());
2203          case 21: return new CE(getMessage());
2204          case 22: return new ST(getMessage());
2205          case 23: return new ID(getMessage(), new Integer( 136 ));
2206          case 24: return new NM(getMessage());
2207          case 25: return new CE(getMessage());
2208          case 26: return new CE(getMessage());
2209          case 27: return new CE(getMessage());
2210          case 28: return new TS(getMessage());
2211          case 29: return new ID(getMessage(), new Integer( 136 ));
2212          case 30: return new ID(getMessage(), new Integer( 136 ));
2213          case 31: return new IS(getMessage(), new Integer( 445 ));
2214          case 32: return new TS(getMessage());
2215          case 33: return new HD(getMessage());
2216          case 34: return new CE(getMessage());
2217          case 35: return new CE(getMessage());
2218          case 36: return new ST(getMessage());
2219          case 37: return new CE(getMessage());
2220          case 38: return new CWE(getMessage());
2221          default: return null;
2222       }
2223   }
2224
2225
2226}
2227