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