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