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