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