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