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