Source code

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