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