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.v27.segment;
35  
36  // import ca.uhn.hl7v2.model.v27.group.*;
37  import ca.uhn.hl7v2.model.v27.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 STF message segment (Staff Identification). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>STF-1: Primary Key Value - STF (CWE) <b>optional </b>
53       * <li>STF-2: Staff Identifier List (CX) <b>optional repeating</b>
54       * <li>STF-3: Staff Name (XPN) <b>optional repeating</b>
55       * <li>STF-4: Staff Type (CWE) <b>optional repeating</b>
56       * <li>STF-5: Administrative Sex (CWE) <b>optional </b>
57       * <li>STF-6: Date/Time of Birth (DTM) <b>optional </b>
58       * <li>STF-7: Active/Inactive Flag (ID) <b>optional </b>
59       * <li>STF-8: Department (CWE) <b>optional repeating</b>
60       * <li>STF-9: Hospital Service - STF (CWE) <b>optional repeating</b>
61       * <li>STF-10: Phone (XTN) <b>optional repeating</b>
62       * <li>STF-11: Office/Home Address/Birthplace (XAD) <b>optional repeating</b>
63       * <li>STF-12: Institution Activation Date (DIN) <b>optional repeating</b>
64       * <li>STF-13: Institution Inactivation Date (DIN) <b>optional repeating</b>
65       * <li>STF-14: Backup Person ID (CWE) <b>optional repeating</b>
66       * <li>STF-15: E-Mail Address (ST) <b>optional repeating</b>
67       * <li>STF-16: Preferred Method of Contact (CWE) <b>optional </b>
68       * <li>STF-17: Marital Status (CWE) <b>optional </b>
69       * <li>STF-18: Job Title (ST) <b>optional </b>
70       * <li>STF-19: Job Code/Class (JCC) <b>optional </b>
71       * <li>STF-20: Employment Status Code (CWE) <b>optional </b>
72       * <li>STF-21: Additional Insured on Auto (ID) <b>optional </b>
73       * <li>STF-22: Driver's License Number - Staff (DLN) <b>optional </b>
74       * <li>STF-23: Copy Auto Ins (ID) <b>optional </b>
75       * <li>STF-24: Auto Ins Expires (DT) <b>optional </b>
76       * <li>STF-25: Date Last DMV Review (DT) <b>optional </b>
77       * <li>STF-26: Date Next DMV Review (DT) <b>optional </b>
78       * <li>STF-27: Race (CWE) <b>optional </b>
79       * <li>STF-28: Ethnic Group (CWE) <b>optional </b>
80       * <li>STF-29: Re-activation Approval Indicator (ID) <b>optional </b>
81       * <li>STF-30: Citizenship (CWE) <b>optional repeating</b>
82       * <li>STF-31: Date/Time of Death (DTM) <b>optional </b>
83       * <li>STF-32: Death Indicator (ID) <b>optional </b>
84       * <li>STF-33: Institution Relationship Type Code (CWE) <b>optional </b>
85       * <li>STF-34: Institution Relationship Period (DR) <b>optional </b>
86       * <li>STF-35: Expected Return Date (DT) <b>optional </b>
87       * <li>STF-36: Cost Center Code (CWE) <b>optional repeating</b>
88       * <li>STF-37: Generic Classification Indicator (ID) <b>optional </b>
89       * <li>STF-38: Inactive Reason Code (CWE) <b>optional </b>
90       * <li>STF-39: Generic resource type or category (CWE) <b>optional repeating</b>
91       * <li>STF-40: Religion (CWE) <b>optional </b>
92       * <li>STF-41: Signature (ED) <b>optional </b>
93   * </ul>
94   */
95  @SuppressWarnings("unused")
96  public class STF extends AbstractSegment {
97  
98      /** 
99       * Creates a new STF segment
100      */
101     public STF(Group parent, ModelClassFactory factory) {
102        super(parent, factory);
103        init(factory);
104     }
105 
106     private void init(ModelClassFactory factory) {
107        try {
108                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Primary Key Value - STF");
109                                   this.add(CX.class, false, 0, 0, new Object[]{ getMessage() }, "Staff Identifier List");
110                                   this.add(XPN.class, false, 0, 0, new Object[]{ getMessage() }, "Staff Name");
111                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Staff Type");
112                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Administrative Sex");
113                                   this.add(DTM.class, false, 1, 0, new Object[]{ getMessage() }, "Date/Time of Birth");
114                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(183) }, "Active/Inactive Flag");
115                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Department");
116                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Hospital Service - STF");
117                                   this.add(XTN.class, false, 0, 0, new Object[]{ getMessage() }, "Phone");
118                                   this.add(XAD.class, false, 0, 0, new Object[]{ getMessage() }, "Office/Home Address/Birthplace");
119                                   this.add(DIN.class, false, 0, 0, new Object[]{ getMessage() }, "Institution Activation Date");
120                                   this.add(DIN.class, false, 0, 0, new Object[]{ getMessage() }, "Institution Inactivation Date");
121                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Backup Person ID");
122                                   this.add(ST.class, false, 0, 0, new Object[]{ getMessage() }, "E-Mail Address");
123                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Preferred Method of Contact");
124                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Marital Status");
125                                   this.add(ST.class, false, 1, 0, new Object[]{ getMessage() }, "Job Title");
126                                   this.add(JCC.class, false, 1, 0, new Object[]{ getMessage() }, "Job Code/Class");
127                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Employment Status Code");
128                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Additional Insured on Auto");
129                                   this.add(DLN.class, false, 1, 0, new Object[]{ getMessage() }, "Driver's License Number - Staff");
130                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Copy Auto Ins");
131                                   this.add(DT.class, false, 1, 0, new Object[]{ getMessage() }, "Auto Ins Expires");
132                                   this.add(DT.class, false, 1, 0, new Object[]{ getMessage() }, "Date Last DMV Review");
133                                   this.add(DT.class, false, 1, 0, new Object[]{ getMessage() }, "Date Next DMV Review");
134                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Race");
135                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Ethnic Group");
136                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Re-activation Approval Indicator");
137                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Citizenship");
138                                   this.add(DTM.class, false, 1, 0, new Object[]{ getMessage() }, "Date/Time of Death");
139                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Death Indicator");
140                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Institution Relationship Type Code");
141                                   this.add(DR.class, false, 1, 0, new Object[]{ getMessage() }, "Institution Relationship Period");
142                                   this.add(DT.class, false, 1, 0, new Object[]{ getMessage() }, "Expected Return Date");
143                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Cost Center Code");
144                                               this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Generic Classification Indicator");
145                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Inactive Reason Code");
146                                   this.add(CWE.class, false, 0, 0, new Object[]{ getMessage() }, "Generic resource type or category");
147                                   this.add(CWE.class, false, 1, 0, new Object[]{ getMessage() }, "Religion");
148                                   this.add(ED.class, false, 1, 0, new Object[]{ getMessage() }, "Signature");
149        } catch(HL7Exception e) {
150           log.error("Unexpected error creating STF - this is probably a bug in the source code generator.", e);
151        }
152     }
153 
154 
155 
156     /**
157      * Returns
158      * STF-1: "Primary Key Value - STF" - creates it if necessary
159      */
160     public CWE getPrimaryKeyValueSTF() { 
161 		CWE retVal = this.getTypedField(1, 0);
162 		return retVal;
163     }
164     
165     /**
166      * Returns
167      * STF-1: "Primary Key Value - STF" - creates it if necessary
168      */
169     public CWE getStf1_PrimaryKeyValueSTF() { 
170 		CWE retVal = this.getTypedField(1, 0);
171 		return retVal;
172     }
173 
174 
175     /**
176      * Returns all repetitions of Staff Identifier List (STF-2).
177      */
178     public CX[] getStaffIdentifierList() {
179     	CX[] retVal = this.getTypedField(2, new CX[0]);
180     	return retVal;
181     }
182 
183 
184     /**
185      * Returns all repetitions of Staff Identifier List (STF-2).
186      */
187     public CX[] getStf2_StaffIdentifierList() {
188     	CX[] retVal = this.getTypedField(2, new CX[0]);
189     	return retVal;
190     }
191 
192 
193     /**
194      * Returns a count of the current number of repetitions of Staff Identifier List (STF-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 getStaffIdentifierListReps() {
199     	return this.getReps(2);
200     }
201 
202 
203     /**
204      * Returns a specific repetition of
205      * STF-2: "Staff Identifier List" - creates it if necessary
206      *
207      * @param rep The repetition index (0-indexed)
208      */
209     public CX getStaffIdentifierList(int rep) { 
210 		CX retVal = this.getTypedField(2, rep);
211 		return retVal;
212     }
213 
214     /**
215      * Returns a specific repetition of
216      * STF-2: "Staff Identifier List" - creates it if necessary
217      *
218      * @param rep The repetition index (0-indexed)
219      */
220     public CX getStf2_StaffIdentifierList(int rep) { 
221 		CX retVal = this.getTypedField(2, rep);
222 		return retVal;
223     }
224 
225     /**
226      * Returns a count of the current number of repetitions of Staff Identifier List (STF-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 getStf2_StaffIdentifierListReps() {
231     	return this.getReps(2);
232     }
233 
234 
235     /**
236      * Inserts a repetition of
237      * STF-2: "Staff Identifier List" 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 CX insertStaffIdentifierList(int rep) throws HL7Exception { 
243         return (CX) super.insertRepetition(2, rep);
244     }
245 
246 
247     /**
248      * Inserts a repetition of
249      * STF-2: "Staff Identifier List" 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 CX insertStf2_StaffIdentifierList(int rep) throws HL7Exception { 
255         return (CX) super.insertRepetition(2, rep);
256     }
257 
258 
259     /**
260      * Removes a repetition of
261      * STF-2: "Staff Identifier List" 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 CX removeStaffIdentifierList(int rep) throws HL7Exception { 
267         return (CX) super.removeRepetition(2, rep);
268     }
269 
270 
271     /**
272      * Removes a repetition of
273      * STF-2: "Staff Identifier List" 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 CX removeStf2_StaffIdentifierList(int rep) throws HL7Exception { 
279         return (CX) super.removeRepetition(2, rep);
280     }
281 
282 
283 
284     /**
285      * Returns all repetitions of Staff Name (STF-3).
286      */
287     public XPN[] getStaffName() {
288     	XPN[] retVal = this.getTypedField(3, new XPN[0]);
289     	return retVal;
290     }
291 
292 
293     /**
294      * Returns all repetitions of Staff Name (STF-3).
295      */
296     public XPN[] getStf3_StaffName() {
297     	XPN[] retVal = this.getTypedField(3, new XPN[0]);
298     	return retVal;
299     }
300 
301 
302     /**
303      * Returns a count of the current number of repetitions of Staff Name (STF-3).
304      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
305      * it will return zero.
306      */
307     public int getStaffNameReps() {
308     	return this.getReps(3);
309     }
310 
311 
312     /**
313      * Returns a specific repetition of
314      * STF-3: "Staff Name" - creates it if necessary
315      *
316      * @param rep The repetition index (0-indexed)
317      */
318     public XPN getStaffName(int rep) { 
319 		XPN retVal = this.getTypedField(3, rep);
320 		return retVal;
321     }
322 
323     /**
324      * Returns a specific repetition of
325      * STF-3: "Staff Name" - creates it if necessary
326      *
327      * @param rep The repetition index (0-indexed)
328      */
329     public XPN getStf3_StaffName(int rep) { 
330 		XPN retVal = this.getTypedField(3, rep);
331 		return retVal;
332     }
333 
334     /**
335      * Returns a count of the current number of repetitions of Staff Name (STF-3).
336      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
337      * it will return zero.
338      */
339     public int getStf3_StaffNameReps() {
340     	return this.getReps(3);
341     }
342 
343 
344     /**
345      * Inserts a repetition of
346      * STF-3: "Staff Name" at a specific index
347      *
348      * @param rep The repetition index (0-indexed)
349      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
350      */
351     public XPN insertStaffName(int rep) throws HL7Exception { 
352         return (XPN) super.insertRepetition(3, rep);
353     }
354 
355 
356     /**
357      * Inserts a repetition of
358      * STF-3: "Staff Name" 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 XPN insertStf3_StaffName(int rep) throws HL7Exception { 
364         return (XPN) super.insertRepetition(3, rep);
365     }
366 
367 
368     /**
369      * Removes a repetition of
370      * STF-3: "Staff Name" 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 XPN removeStaffName(int rep) throws HL7Exception { 
376         return (XPN) super.removeRepetition(3, rep);
377     }
378 
379 
380     /**
381      * Removes a repetition of
382      * STF-3: "Staff Name" 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 XPN removeStf3_StaffName(int rep) throws HL7Exception { 
388         return (XPN) super.removeRepetition(3, rep);
389     }
390 
391 
392 
393     /**
394      * Returns all repetitions of Staff Type (STF-4).
395      */
396     public CWE[] getStaffType() {
397     	CWE[] retVal = this.getTypedField(4, new CWE[0]);
398     	return retVal;
399     }
400 
401 
402     /**
403      * Returns all repetitions of Staff Type (STF-4).
404      */
405     public CWE[] getStf4_StaffType() {
406     	CWE[] retVal = this.getTypedField(4, new CWE[0]);
407     	return retVal;
408     }
409 
410 
411     /**
412      * Returns a count of the current number of repetitions of Staff Type (STF-4).
413      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
414      * it will return zero.
415      */
416     public int getStaffTypeReps() {
417     	return this.getReps(4);
418     }
419 
420 
421     /**
422      * Returns a specific repetition of
423      * STF-4: "Staff Type" - creates it if necessary
424      *
425      * @param rep The repetition index (0-indexed)
426      */
427     public CWE getStaffType(int rep) { 
428 		CWE retVal = this.getTypedField(4, rep);
429 		return retVal;
430     }
431 
432     /**
433      * Returns a specific repetition of
434      * STF-4: "Staff Type" - creates it if necessary
435      *
436      * @param rep The repetition index (0-indexed)
437      */
438     public CWE getStf4_StaffType(int rep) { 
439 		CWE retVal = this.getTypedField(4, rep);
440 		return retVal;
441     }
442 
443     /**
444      * Returns a count of the current number of repetitions of Staff Type (STF-4).
445      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
446      * it will return zero.
447      */
448     public int getStf4_StaffTypeReps() {
449     	return this.getReps(4);
450     }
451 
452 
453     /**
454      * Inserts a repetition of
455      * STF-4: "Staff Type" at a specific index
456      *
457      * @param rep The repetition index (0-indexed)
458      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
459      */
460     public CWE insertStaffType(int rep) throws HL7Exception { 
461         return (CWE) super.insertRepetition(4, rep);
462     }
463 
464 
465     /**
466      * Inserts a repetition of
467      * STF-4: "Staff Type" 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 CWE insertStf4_StaffType(int rep) throws HL7Exception { 
473         return (CWE) super.insertRepetition(4, rep);
474     }
475 
476 
477     /**
478      * Removes a repetition of
479      * STF-4: "Staff Type" 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 CWE removeStaffType(int rep) throws HL7Exception { 
485         return (CWE) super.removeRepetition(4, rep);
486     }
487 
488 
489     /**
490      * Removes a repetition of
491      * STF-4: "Staff Type" 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 CWE removeStf4_StaffType(int rep) throws HL7Exception { 
497         return (CWE) super.removeRepetition(4, rep);
498     }
499 
500 
501 
502 
503     /**
504      * Returns
505      * STF-5: "Administrative Sex" - creates it if necessary
506      */
507     public CWE getAdministrativeSex() { 
508 		CWE retVal = this.getTypedField(5, 0);
509 		return retVal;
510     }
511     
512     /**
513      * Returns
514      * STF-5: "Administrative Sex" - creates it if necessary
515      */
516     public CWE getStf5_AdministrativeSex() { 
517 		CWE retVal = this.getTypedField(5, 0);
518 		return retVal;
519     }
520 
521 
522 
523     /**
524      * Returns
525      * STF-6: "Date/Time of Birth" - creates it if necessary
526      */
527     public DTM getDateTimeOfBirth() { 
528 		DTM retVal = this.getTypedField(6, 0);
529 		return retVal;
530     }
531     
532     /**
533      * Returns
534      * STF-6: "Date/Time of Birth" - creates it if necessary
535      */
536     public DTM getStf6_DateTimeOfBirth() { 
537 		DTM retVal = this.getTypedField(6, 0);
538 		return retVal;
539     }
540 
541 
542 
543     /**
544      * Returns
545      * STF-7: "Active/Inactive Flag" - creates it if necessary
546      */
547     public ID getActiveInactiveFlag() { 
548 		ID retVal = this.getTypedField(7, 0);
549 		return retVal;
550     }
551     
552     /**
553      * Returns
554      * STF-7: "Active/Inactive Flag" - creates it if necessary
555      */
556     public ID getStf7_ActiveInactiveFlag() { 
557 		ID retVal = this.getTypedField(7, 0);
558 		return retVal;
559     }
560 
561 
562     /**
563      * Returns all repetitions of Department (STF-8).
564      */
565     public CWE[] getDepartment() {
566     	CWE[] retVal = this.getTypedField(8, new CWE[0]);
567     	return retVal;
568     }
569 
570 
571     /**
572      * Returns all repetitions of Department (STF-8).
573      */
574     public CWE[] getStf8_Department() {
575     	CWE[] retVal = this.getTypedField(8, new CWE[0]);
576     	return retVal;
577     }
578 
579 
580     /**
581      * Returns a count of the current number of repetitions of Department (STF-8).
582      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
583      * it will return zero.
584      */
585     public int getDepartmentReps() {
586     	return this.getReps(8);
587     }
588 
589 
590     /**
591      * Returns a specific repetition of
592      * STF-8: "Department" - creates it if necessary
593      *
594      * @param rep The repetition index (0-indexed)
595      */
596     public CWE getDepartment(int rep) { 
597 		CWE retVal = this.getTypedField(8, rep);
598 		return retVal;
599     }
600 
601     /**
602      * Returns a specific repetition of
603      * STF-8: "Department" - creates it if necessary
604      *
605      * @param rep The repetition index (0-indexed)
606      */
607     public CWE getStf8_Department(int rep) { 
608 		CWE retVal = this.getTypedField(8, rep);
609 		return retVal;
610     }
611 
612     /**
613      * Returns a count of the current number of repetitions of Department (STF-8).
614      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
615      * it will return zero.
616      */
617     public int getStf8_DepartmentReps() {
618     	return this.getReps(8);
619     }
620 
621 
622     /**
623      * Inserts a repetition of
624      * STF-8: "Department" at a specific index
625      *
626      * @param rep The repetition index (0-indexed)
627      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
628      */
629     public CWE insertDepartment(int rep) throws HL7Exception { 
630         return (CWE) super.insertRepetition(8, rep);
631     }
632 
633 
634     /**
635      * Inserts a repetition of
636      * STF-8: "Department" at a specific index
637      *
638      * @param rep The repetition index (0-indexed)
639      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
640      */
641     public CWE insertStf8_Department(int rep) throws HL7Exception { 
642         return (CWE) super.insertRepetition(8, rep);
643     }
644 
645 
646     /**
647      * Removes a repetition of
648      * STF-8: "Department" at a specific index
649      *
650      * @param rep The repetition index (0-indexed)
651      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
652      */
653     public CWE removeDepartment(int rep) throws HL7Exception { 
654         return (CWE) super.removeRepetition(8, rep);
655     }
656 
657 
658     /**
659      * Removes a repetition of
660      * STF-8: "Department" at a specific index
661      *
662      * @param rep The repetition index (0-indexed)
663      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
664      */
665     public CWE removeStf8_Department(int rep) throws HL7Exception { 
666         return (CWE) super.removeRepetition(8, rep);
667     }
668 
669 
670 
671     /**
672      * Returns all repetitions of Hospital Service - STF (STF-9).
673      */
674     public CWE[] getHospitalServiceSTF() {
675     	CWE[] retVal = this.getTypedField(9, new CWE[0]);
676     	return retVal;
677     }
678 
679 
680     /**
681      * Returns all repetitions of Hospital Service - STF (STF-9).
682      */
683     public CWE[] getStf9_HospitalServiceSTF() {
684     	CWE[] retVal = this.getTypedField(9, new CWE[0]);
685     	return retVal;
686     }
687 
688 
689     /**
690      * Returns a count of the current number of repetitions of Hospital Service - STF (STF-9).
691      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
692      * it will return zero.
693      */
694     public int getHospitalServiceSTFReps() {
695     	return this.getReps(9);
696     }
697 
698 
699     /**
700      * Returns a specific repetition of
701      * STF-9: "Hospital Service - STF" - creates it if necessary
702      *
703      * @param rep The repetition index (0-indexed)
704      */
705     public CWE getHospitalServiceSTF(int rep) { 
706 		CWE retVal = this.getTypedField(9, rep);
707 		return retVal;
708     }
709 
710     /**
711      * Returns a specific repetition of
712      * STF-9: "Hospital Service - STF" - creates it if necessary
713      *
714      * @param rep The repetition index (0-indexed)
715      */
716     public CWE getStf9_HospitalServiceSTF(int rep) { 
717 		CWE retVal = this.getTypedField(9, rep);
718 		return retVal;
719     }
720 
721     /**
722      * Returns a count of the current number of repetitions of Hospital Service - STF (STF-9).
723      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
724      * it will return zero.
725      */
726     public int getStf9_HospitalServiceSTFReps() {
727     	return this.getReps(9);
728     }
729 
730 
731     /**
732      * Inserts a repetition of
733      * STF-9: "Hospital Service - STF" at a specific index
734      *
735      * @param rep The repetition index (0-indexed)
736      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
737      */
738     public CWE insertHospitalServiceSTF(int rep) throws HL7Exception { 
739         return (CWE) super.insertRepetition(9, rep);
740     }
741 
742 
743     /**
744      * Inserts a repetition of
745      * STF-9: "Hospital Service - STF" at a specific index
746      *
747      * @param rep The repetition index (0-indexed)
748      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
749      */
750     public CWE insertStf9_HospitalServiceSTF(int rep) throws HL7Exception { 
751         return (CWE) super.insertRepetition(9, rep);
752     }
753 
754 
755     /**
756      * Removes a repetition of
757      * STF-9: "Hospital Service - STF" at a specific index
758      *
759      * @param rep The repetition index (0-indexed)
760      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
761      */
762     public CWE removeHospitalServiceSTF(int rep) throws HL7Exception { 
763         return (CWE) super.removeRepetition(9, rep);
764     }
765 
766 
767     /**
768      * Removes a repetition of
769      * STF-9: "Hospital Service - STF" at a specific index
770      *
771      * @param rep The repetition index (0-indexed)
772      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
773      */
774     public CWE removeStf9_HospitalServiceSTF(int rep) throws HL7Exception { 
775         return (CWE) super.removeRepetition(9, rep);
776     }
777 
778 
779 
780     /**
781      * Returns all repetitions of Phone (STF-10).
782      */
783     public XTN[] getPhone() {
784     	XTN[] retVal = this.getTypedField(10, new XTN[0]);
785     	return retVal;
786     }
787 
788 
789     /**
790      * Returns all repetitions of Phone (STF-10).
791      */
792     public XTN[] getStf10_Phone() {
793     	XTN[] retVal = this.getTypedField(10, new XTN[0]);
794     	return retVal;
795     }
796 
797 
798     /**
799      * Returns a count of the current number of repetitions of Phone (STF-10).
800      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
801      * it will return zero.
802      */
803     public int getPhoneReps() {
804     	return this.getReps(10);
805     }
806 
807 
808     /**
809      * Returns a specific repetition of
810      * STF-10: "Phone" - creates it if necessary
811      *
812      * @param rep The repetition index (0-indexed)
813      */
814     public XTN getPhone(int rep) { 
815 		XTN retVal = this.getTypedField(10, rep);
816 		return retVal;
817     }
818 
819     /**
820      * Returns a specific repetition of
821      * STF-10: "Phone" - creates it if necessary
822      *
823      * @param rep The repetition index (0-indexed)
824      */
825     public XTN getStf10_Phone(int rep) { 
826 		XTN retVal = this.getTypedField(10, rep);
827 		return retVal;
828     }
829 
830     /**
831      * Returns a count of the current number of repetitions of Phone (STF-10).
832      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
833      * it will return zero.
834      */
835     public int getStf10_PhoneReps() {
836     	return this.getReps(10);
837     }
838 
839 
840     /**
841      * Inserts a repetition of
842      * STF-10: "Phone" at a specific index
843      *
844      * @param rep The repetition index (0-indexed)
845      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
846      */
847     public XTN insertPhone(int rep) throws HL7Exception { 
848         return (XTN) super.insertRepetition(10, rep);
849     }
850 
851 
852     /**
853      * Inserts a repetition of
854      * STF-10: "Phone" at a specific index
855      *
856      * @param rep The repetition index (0-indexed)
857      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
858      */
859     public XTN insertStf10_Phone(int rep) throws HL7Exception { 
860         return (XTN) super.insertRepetition(10, rep);
861     }
862 
863 
864     /**
865      * Removes a repetition of
866      * STF-10: "Phone" at a specific index
867      *
868      * @param rep The repetition index (0-indexed)
869      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
870      */
871     public XTN removePhone(int rep) throws HL7Exception { 
872         return (XTN) super.removeRepetition(10, rep);
873     }
874 
875 
876     /**
877      * Removes a repetition of
878      * STF-10: "Phone" at a specific index
879      *
880      * @param rep The repetition index (0-indexed)
881      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
882      */
883     public XTN removeStf10_Phone(int rep) throws HL7Exception { 
884         return (XTN) super.removeRepetition(10, rep);
885     }
886 
887 
888 
889     /**
890      * Returns all repetitions of Office/Home Address/Birthplace (STF-11).
891      */
892     public XAD[] getOfficeHomeAddressBirthplace() {
893     	XAD[] retVal = this.getTypedField(11, new XAD[0]);
894     	return retVal;
895     }
896 
897 
898     /**
899      * Returns all repetitions of Office/Home Address/Birthplace (STF-11).
900      */
901     public XAD[] getStf11_OfficeHomeAddressBirthplace() {
902     	XAD[] retVal = this.getTypedField(11, new XAD[0]);
903     	return retVal;
904     }
905 
906 
907     /**
908      * Returns a count of the current number of repetitions of Office/Home Address/Birthplace (STF-11).
909      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
910      * it will return zero.
911      */
912     public int getOfficeHomeAddressBirthplaceReps() {
913     	return this.getReps(11);
914     }
915 
916 
917     /**
918      * Returns a specific repetition of
919      * STF-11: "Office/Home Address/Birthplace" - creates it if necessary
920      *
921      * @param rep The repetition index (0-indexed)
922      */
923     public XAD getOfficeHomeAddressBirthplace(int rep) { 
924 		XAD retVal = this.getTypedField(11, rep);
925 		return retVal;
926     }
927 
928     /**
929      * Returns a specific repetition of
930      * STF-11: "Office/Home Address/Birthplace" - creates it if necessary
931      *
932      * @param rep The repetition index (0-indexed)
933      */
934     public XAD getStf11_OfficeHomeAddressBirthplace(int rep) { 
935 		XAD retVal = this.getTypedField(11, rep);
936 		return retVal;
937     }
938 
939     /**
940      * Returns a count of the current number of repetitions of Office/Home Address/Birthplace (STF-11).
941      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
942      * it will return zero.
943      */
944     public int getStf11_OfficeHomeAddressBirthplaceReps() {
945     	return this.getReps(11);
946     }
947 
948 
949     /**
950      * Inserts a repetition of
951      * STF-11: "Office/Home Address/Birthplace" at a specific index
952      *
953      * @param rep The repetition index (0-indexed)
954      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
955      */
956     public XAD insertOfficeHomeAddressBirthplace(int rep) throws HL7Exception { 
957         return (XAD) super.insertRepetition(11, rep);
958     }
959 
960 
961     /**
962      * Inserts a repetition of
963      * STF-11: "Office/Home Address/Birthplace" at a specific index
964      *
965      * @param rep The repetition index (0-indexed)
966      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
967      */
968     public XAD insertStf11_OfficeHomeAddressBirthplace(int rep) throws HL7Exception { 
969         return (XAD) super.insertRepetition(11, rep);
970     }
971 
972 
973     /**
974      * Removes a repetition of
975      * STF-11: "Office/Home Address/Birthplace" at a specific index
976      *
977      * @param rep The repetition index (0-indexed)
978      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
979      */
980     public XAD removeOfficeHomeAddressBirthplace(int rep) throws HL7Exception { 
981         return (XAD) super.removeRepetition(11, rep);
982     }
983 
984 
985     /**
986      * Removes a repetition of
987      * STF-11: "Office/Home Address/Birthplace" at a specific index
988      *
989      * @param rep The repetition index (0-indexed)
990      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
991      */
992     public XAD removeStf11_OfficeHomeAddressBirthplace(int rep) throws HL7Exception { 
993         return (XAD) super.removeRepetition(11, rep);
994     }
995 
996 
997 
998     /**
999      * Returns all repetitions of Institution Activation Date (STF-12).
1000      */
1001     public DIN[] getInstitutionActivationDate() {
1002     	DIN[] retVal = this.getTypedField(12, new DIN[0]);
1003     	return retVal;
1004     }
1005 
1006 
1007     /**
1008      * Returns all repetitions of Institution Activation Date (STF-12).
1009      */
1010     public DIN[] getStf12_InstitutionActivationDate() {
1011     	DIN[] retVal = this.getTypedField(12, new DIN[0]);
1012     	return retVal;
1013     }
1014 
1015 
1016     /**
1017      * Returns a count of the current number of repetitions of Institution Activation Date (STF-12).
1018      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1019      * it will return zero.
1020      */
1021     public int getInstitutionActivationDateReps() {
1022     	return this.getReps(12);
1023     }
1024 
1025 
1026     /**
1027      * Returns a specific repetition of
1028      * STF-12: "Institution Activation Date" - creates it if necessary
1029      *
1030      * @param rep The repetition index (0-indexed)
1031      */
1032     public DIN getInstitutionActivationDate(int rep) { 
1033 		DIN retVal = this.getTypedField(12, rep);
1034 		return retVal;
1035     }
1036 
1037     /**
1038      * Returns a specific repetition of
1039      * STF-12: "Institution Activation Date" - creates it if necessary
1040      *
1041      * @param rep The repetition index (0-indexed)
1042      */
1043     public DIN getStf12_InstitutionActivationDate(int rep) { 
1044 		DIN retVal = this.getTypedField(12, rep);
1045 		return retVal;
1046     }
1047 
1048     /**
1049      * Returns a count of the current number of repetitions of Institution Activation Date (STF-12).
1050      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1051      * it will return zero.
1052      */
1053     public int getStf12_InstitutionActivationDateReps() {
1054     	return this.getReps(12);
1055     }
1056 
1057 
1058     /**
1059      * Inserts a repetition of
1060      * STF-12: "Institution Activation Date" at a specific index
1061      *
1062      * @param rep The repetition index (0-indexed)
1063      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1064      */
1065     public DIN insertInstitutionActivationDate(int rep) throws HL7Exception { 
1066         return (DIN) super.insertRepetition(12, rep);
1067     }
1068 
1069 
1070     /**
1071      * Inserts a repetition of
1072      * STF-12: "Institution Activation Date" at a specific index
1073      *
1074      * @param rep The repetition index (0-indexed)
1075      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1076      */
1077     public DIN insertStf12_InstitutionActivationDate(int rep) throws HL7Exception { 
1078         return (DIN) super.insertRepetition(12, rep);
1079     }
1080 
1081 
1082     /**
1083      * Removes a repetition of
1084      * STF-12: "Institution Activation Date" at a specific index
1085      *
1086      * @param rep The repetition index (0-indexed)
1087      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1088      */
1089     public DIN removeInstitutionActivationDate(int rep) throws HL7Exception { 
1090         return (DIN) super.removeRepetition(12, rep);
1091     }
1092 
1093 
1094     /**
1095      * Removes a repetition of
1096      * STF-12: "Institution Activation Date" at a specific index
1097      *
1098      * @param rep The repetition index (0-indexed)
1099      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1100      */
1101     public DIN removeStf12_InstitutionActivationDate(int rep) throws HL7Exception { 
1102         return (DIN) super.removeRepetition(12, rep);
1103     }
1104 
1105 
1106 
1107     /**
1108      * Returns all repetitions of Institution Inactivation Date (STF-13).
1109      */
1110     public DIN[] getInstitutionInactivationDate() {
1111     	DIN[] retVal = this.getTypedField(13, new DIN[0]);
1112     	return retVal;
1113     }
1114 
1115 
1116     /**
1117      * Returns all repetitions of Institution Inactivation Date (STF-13).
1118      */
1119     public DIN[] getStf13_InstitutionInactivationDate() {
1120     	DIN[] retVal = this.getTypedField(13, new DIN[0]);
1121     	return retVal;
1122     }
1123 
1124 
1125     /**
1126      * Returns a count of the current number of repetitions of Institution Inactivation Date (STF-13).
1127      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1128      * it will return zero.
1129      */
1130     public int getInstitutionInactivationDateReps() {
1131     	return this.getReps(13);
1132     }
1133 
1134 
1135     /**
1136      * Returns a specific repetition of
1137      * STF-13: "Institution Inactivation Date" - creates it if necessary
1138      *
1139      * @param rep The repetition index (0-indexed)
1140      */
1141     public DIN getInstitutionInactivationDate(int rep) { 
1142 		DIN retVal = this.getTypedField(13, rep);
1143 		return retVal;
1144     }
1145 
1146     /**
1147      * Returns a specific repetition of
1148      * STF-13: "Institution Inactivation Date" - creates it if necessary
1149      *
1150      * @param rep The repetition index (0-indexed)
1151      */
1152     public DIN getStf13_InstitutionInactivationDate(int rep) { 
1153 		DIN retVal = this.getTypedField(13, rep);
1154 		return retVal;
1155     }
1156 
1157     /**
1158      * Returns a count of the current number of repetitions of Institution Inactivation Date (STF-13).
1159      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1160      * it will return zero.
1161      */
1162     public int getStf13_InstitutionInactivationDateReps() {
1163     	return this.getReps(13);
1164     }
1165 
1166 
1167     /**
1168      * Inserts a repetition of
1169      * STF-13: "Institution Inactivation Date" at a specific index
1170      *
1171      * @param rep The repetition index (0-indexed)
1172      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1173      */
1174     public DIN insertInstitutionInactivationDate(int rep) throws HL7Exception { 
1175         return (DIN) super.insertRepetition(13, rep);
1176     }
1177 
1178 
1179     /**
1180      * Inserts a repetition of
1181      * STF-13: "Institution Inactivation Date" at a specific index
1182      *
1183      * @param rep The repetition index (0-indexed)
1184      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1185      */
1186     public DIN insertStf13_InstitutionInactivationDate(int rep) throws HL7Exception { 
1187         return (DIN) super.insertRepetition(13, rep);
1188     }
1189 
1190 
1191     /**
1192      * Removes a repetition of
1193      * STF-13: "Institution Inactivation Date" at a specific index
1194      *
1195      * @param rep The repetition index (0-indexed)
1196      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1197      */
1198     public DIN removeInstitutionInactivationDate(int rep) throws HL7Exception { 
1199         return (DIN) super.removeRepetition(13, rep);
1200     }
1201 
1202 
1203     /**
1204      * Removes a repetition of
1205      * STF-13: "Institution Inactivation Date" at a specific index
1206      *
1207      * @param rep The repetition index (0-indexed)
1208      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1209      */
1210     public DIN removeStf13_InstitutionInactivationDate(int rep) throws HL7Exception { 
1211         return (DIN) super.removeRepetition(13, rep);
1212     }
1213 
1214 
1215 
1216     /**
1217      * Returns all repetitions of Backup Person ID (STF-14).
1218      */
1219     public CWE[] getBackupPersonID() {
1220     	CWE[] retVal = this.getTypedField(14, new CWE[0]);
1221     	return retVal;
1222     }
1223 
1224 
1225     /**
1226      * Returns all repetitions of Backup Person ID (STF-14).
1227      */
1228     public CWE[] getStf14_BackupPersonID() {
1229     	CWE[] retVal = this.getTypedField(14, new CWE[0]);
1230     	return retVal;
1231     }
1232 
1233 
1234     /**
1235      * Returns a count of the current number of repetitions of Backup Person ID (STF-14).
1236      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1237      * it will return zero.
1238      */
1239     public int getBackupPersonIDReps() {
1240     	return this.getReps(14);
1241     }
1242 
1243 
1244     /**
1245      * Returns a specific repetition of
1246      * STF-14: "Backup Person ID" - creates it if necessary
1247      *
1248      * @param rep The repetition index (0-indexed)
1249      */
1250     public CWE getBackupPersonID(int rep) { 
1251 		CWE retVal = this.getTypedField(14, rep);
1252 		return retVal;
1253     }
1254 
1255     /**
1256      * Returns a specific repetition of
1257      * STF-14: "Backup Person ID" - creates it if necessary
1258      *
1259      * @param rep The repetition index (0-indexed)
1260      */
1261     public CWE getStf14_BackupPersonID(int rep) { 
1262 		CWE retVal = this.getTypedField(14, rep);
1263 		return retVal;
1264     }
1265 
1266     /**
1267      * Returns a count of the current number of repetitions of Backup Person ID (STF-14).
1268      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1269      * it will return zero.
1270      */
1271     public int getStf14_BackupPersonIDReps() {
1272     	return this.getReps(14);
1273     }
1274 
1275 
1276     /**
1277      * Inserts a repetition of
1278      * STF-14: "Backup Person ID" at a specific index
1279      *
1280      * @param rep The repetition index (0-indexed)
1281      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1282      */
1283     public CWE insertBackupPersonID(int rep) throws HL7Exception { 
1284         return (CWE) super.insertRepetition(14, rep);
1285     }
1286 
1287 
1288     /**
1289      * Inserts a repetition of
1290      * STF-14: "Backup Person ID" at a specific index
1291      *
1292      * @param rep The repetition index (0-indexed)
1293      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1294      */
1295     public CWE insertStf14_BackupPersonID(int rep) throws HL7Exception { 
1296         return (CWE) super.insertRepetition(14, rep);
1297     }
1298 
1299 
1300     /**
1301      * Removes a repetition of
1302      * STF-14: "Backup Person ID" at a specific index
1303      *
1304      * @param rep The repetition index (0-indexed)
1305      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1306      */
1307     public CWE removeBackupPersonID(int rep) throws HL7Exception { 
1308         return (CWE) super.removeRepetition(14, rep);
1309     }
1310 
1311 
1312     /**
1313      * Removes a repetition of
1314      * STF-14: "Backup Person ID" at a specific index
1315      *
1316      * @param rep The repetition index (0-indexed)
1317      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1318      */
1319     public CWE removeStf14_BackupPersonID(int rep) throws HL7Exception { 
1320         return (CWE) super.removeRepetition(14, rep);
1321     }
1322 
1323 
1324 
1325     /**
1326      * Returns all repetitions of E-Mail Address (STF-15).
1327      */
1328     public ST[] getEMailAddress() {
1329     	ST[] retVal = this.getTypedField(15, new ST[0]);
1330     	return retVal;
1331     }
1332 
1333 
1334     /**
1335      * Returns all repetitions of E-Mail Address (STF-15).
1336      */
1337     public ST[] getStf15_EMailAddress() {
1338     	ST[] retVal = this.getTypedField(15, new ST[0]);
1339     	return retVal;
1340     }
1341 
1342 
1343     /**
1344      * Returns a count of the current number of repetitions of E-Mail Address (STF-15).
1345      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1346      * it will return zero.
1347      */
1348     public int getEMailAddressReps() {
1349     	return this.getReps(15);
1350     }
1351 
1352 
1353     /**
1354      * Returns a specific repetition of
1355      * STF-15: "E-Mail Address" - creates it if necessary
1356      *
1357      * @param rep The repetition index (0-indexed)
1358      */
1359     public ST getEMailAddress(int rep) { 
1360 		ST retVal = this.getTypedField(15, rep);
1361 		return retVal;
1362     }
1363 
1364     /**
1365      * Returns a specific repetition of
1366      * STF-15: "E-Mail Address" - creates it if necessary
1367      *
1368      * @param rep The repetition index (0-indexed)
1369      */
1370     public ST getStf15_EMailAddress(int rep) { 
1371 		ST retVal = this.getTypedField(15, rep);
1372 		return retVal;
1373     }
1374 
1375     /**
1376      * Returns a count of the current number of repetitions of E-Mail Address (STF-15).
1377      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1378      * it will return zero.
1379      */
1380     public int getStf15_EMailAddressReps() {
1381     	return this.getReps(15);
1382     }
1383 
1384 
1385     /**
1386      * Inserts a repetition of
1387      * STF-15: "E-Mail Address" at a specific index
1388      *
1389      * @param rep The repetition index (0-indexed)
1390      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1391      */
1392     public ST insertEMailAddress(int rep) throws HL7Exception { 
1393         return (ST) super.insertRepetition(15, rep);
1394     }
1395 
1396 
1397     /**
1398      * Inserts a repetition of
1399      * STF-15: "E-Mail Address" at a specific index
1400      *
1401      * @param rep The repetition index (0-indexed)
1402      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1403      */
1404     public ST insertStf15_EMailAddress(int rep) throws HL7Exception { 
1405         return (ST) super.insertRepetition(15, rep);
1406     }
1407 
1408 
1409     /**
1410      * Removes a repetition of
1411      * STF-15: "E-Mail Address" at a specific index
1412      *
1413      * @param rep The repetition index (0-indexed)
1414      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1415      */
1416     public ST removeEMailAddress(int rep) throws HL7Exception { 
1417         return (ST) super.removeRepetition(15, rep);
1418     }
1419 
1420 
1421     /**
1422      * Removes a repetition of
1423      * STF-15: "E-Mail Address" at a specific index
1424      *
1425      * @param rep The repetition index (0-indexed)
1426      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1427      */
1428     public ST removeStf15_EMailAddress(int rep) throws HL7Exception { 
1429         return (ST) super.removeRepetition(15, rep);
1430     }
1431 
1432 
1433 
1434 
1435     /**
1436      * Returns
1437      * STF-16: "Preferred Method of Contact" - creates it if necessary
1438      */
1439     public CWE getPreferredMethodOfContact() { 
1440 		CWE retVal = this.getTypedField(16, 0);
1441 		return retVal;
1442     }
1443     
1444     /**
1445      * Returns
1446      * STF-16: "Preferred Method of Contact" - creates it if necessary
1447      */
1448     public CWE getStf16_PreferredMethodOfContact() { 
1449 		CWE retVal = this.getTypedField(16, 0);
1450 		return retVal;
1451     }
1452 
1453 
1454 
1455     /**
1456      * Returns
1457      * STF-17: "Marital Status" - creates it if necessary
1458      */
1459     public CWE getMaritalStatus() { 
1460 		CWE retVal = this.getTypedField(17, 0);
1461 		return retVal;
1462     }
1463     
1464     /**
1465      * Returns
1466      * STF-17: "Marital Status" - creates it if necessary
1467      */
1468     public CWE getStf17_MaritalStatus() { 
1469 		CWE retVal = this.getTypedField(17, 0);
1470 		return retVal;
1471     }
1472 
1473 
1474 
1475     /**
1476      * Returns
1477      * STF-18: "Job Title" - creates it if necessary
1478      */
1479     public ST getJobTitle() { 
1480 		ST retVal = this.getTypedField(18, 0);
1481 		return retVal;
1482     }
1483     
1484     /**
1485      * Returns
1486      * STF-18: "Job Title" - creates it if necessary
1487      */
1488     public ST getStf18_JobTitle() { 
1489 		ST retVal = this.getTypedField(18, 0);
1490 		return retVal;
1491     }
1492 
1493 
1494 
1495     /**
1496      * Returns
1497      * STF-19: "Job Code/Class" - creates it if necessary
1498      */
1499     public JCC getJobCodeClass() { 
1500 		JCC retVal = this.getTypedField(19, 0);
1501 		return retVal;
1502     }
1503     
1504     /**
1505      * Returns
1506      * STF-19: "Job Code/Class" - creates it if necessary
1507      */
1508     public JCC getStf19_JobCodeClass() { 
1509 		JCC retVal = this.getTypedField(19, 0);
1510 		return retVal;
1511     }
1512 
1513 
1514 
1515     /**
1516      * Returns
1517      * STF-20: "Employment Status Code" - creates it if necessary
1518      */
1519     public CWE getEmploymentStatusCode() { 
1520 		CWE retVal = this.getTypedField(20, 0);
1521 		return retVal;
1522     }
1523     
1524     /**
1525      * Returns
1526      * STF-20: "Employment Status Code" - creates it if necessary
1527      */
1528     public CWE getStf20_EmploymentStatusCode() { 
1529 		CWE retVal = this.getTypedField(20, 0);
1530 		return retVal;
1531     }
1532 
1533 
1534 
1535     /**
1536      * Returns
1537      * STF-21: "Additional Insured on Auto" - creates it if necessary
1538      */
1539     public ID getAdditionalInsuredOnAuto() { 
1540 		ID retVal = this.getTypedField(21, 0);
1541 		return retVal;
1542     }
1543     
1544     /**
1545      * Returns
1546      * STF-21: "Additional Insured on Auto" - creates it if necessary
1547      */
1548     public ID getStf21_AdditionalInsuredOnAuto() { 
1549 		ID retVal = this.getTypedField(21, 0);
1550 		return retVal;
1551     }
1552 
1553 
1554 
1555     /**
1556      * Returns
1557      * STF-22: "Driver's License Number - Staff" - creates it if necessary
1558      */
1559     public DLN getDriverSLicenseNumberStaff() { 
1560 		DLN retVal = this.getTypedField(22, 0);
1561 		return retVal;
1562     }
1563     
1564     /**
1565      * Returns
1566      * STF-22: "Driver's License Number - Staff" - creates it if necessary
1567      */
1568     public DLN getStf22_DriverSLicenseNumberStaff() { 
1569 		DLN retVal = this.getTypedField(22, 0);
1570 		return retVal;
1571     }
1572 
1573 
1574 
1575     /**
1576      * Returns
1577      * STF-23: "Copy Auto Ins" - creates it if necessary
1578      */
1579     public ID getCopyAutoIns() { 
1580 		ID retVal = this.getTypedField(23, 0);
1581 		return retVal;
1582     }
1583     
1584     /**
1585      * Returns
1586      * STF-23: "Copy Auto Ins" - creates it if necessary
1587      */
1588     public ID getStf23_CopyAutoIns() { 
1589 		ID retVal = this.getTypedField(23, 0);
1590 		return retVal;
1591     }
1592 
1593 
1594 
1595     /**
1596      * Returns
1597      * STF-24: "Auto Ins Expires" - creates it if necessary
1598      */
1599     public DT getAutoInsExpires() { 
1600 		DT retVal = this.getTypedField(24, 0);
1601 		return retVal;
1602     }
1603     
1604     /**
1605      * Returns
1606      * STF-24: "Auto Ins Expires" - creates it if necessary
1607      */
1608     public DT getStf24_AutoInsExpires() { 
1609 		DT retVal = this.getTypedField(24, 0);
1610 		return retVal;
1611     }
1612 
1613 
1614 
1615     /**
1616      * Returns
1617      * STF-25: "Date Last DMV Review" - creates it if necessary
1618      */
1619     public DT getDateLastDMVReview() { 
1620 		DT retVal = this.getTypedField(25, 0);
1621 		return retVal;
1622     }
1623     
1624     /**
1625      * Returns
1626      * STF-25: "Date Last DMV Review" - creates it if necessary
1627      */
1628     public DT getStf25_DateLastDMVReview() { 
1629 		DT retVal = this.getTypedField(25, 0);
1630 		return retVal;
1631     }
1632 
1633 
1634 
1635     /**
1636      * Returns
1637      * STF-26: "Date Next DMV Review" - creates it if necessary
1638      */
1639     public DT getDateNextDMVReview() { 
1640 		DT retVal = this.getTypedField(26, 0);
1641 		return retVal;
1642     }
1643     
1644     /**
1645      * Returns
1646      * STF-26: "Date Next DMV Review" - creates it if necessary
1647      */
1648     public DT getStf26_DateNextDMVReview() { 
1649 		DT retVal = this.getTypedField(26, 0);
1650 		return retVal;
1651     }
1652 
1653 
1654 
1655     /**
1656      * Returns
1657      * STF-27: "Race" - creates it if necessary
1658      */
1659     public CWE getRace() { 
1660 		CWE retVal = this.getTypedField(27, 0);
1661 		return retVal;
1662     }
1663     
1664     /**
1665      * Returns
1666      * STF-27: "Race" - creates it if necessary
1667      */
1668     public CWE getStf27_Race() { 
1669 		CWE retVal = this.getTypedField(27, 0);
1670 		return retVal;
1671     }
1672 
1673 
1674 
1675     /**
1676      * Returns
1677      * STF-28: "Ethnic Group" - creates it if necessary
1678      */
1679     public CWE getEthnicGroup() { 
1680 		CWE retVal = this.getTypedField(28, 0);
1681 		return retVal;
1682     }
1683     
1684     /**
1685      * Returns
1686      * STF-28: "Ethnic Group" - creates it if necessary
1687      */
1688     public CWE getStf28_EthnicGroup() { 
1689 		CWE retVal = this.getTypedField(28, 0);
1690 		return retVal;
1691     }
1692 
1693 
1694 
1695     /**
1696      * Returns
1697      * STF-29: "Re-activation Approval Indicator" - creates it if necessary
1698      */
1699     public ID getReActivationApprovalIndicator() { 
1700 		ID retVal = this.getTypedField(29, 0);
1701 		return retVal;
1702     }
1703     
1704     /**
1705      * Returns
1706      * STF-29: "Re-activation Approval Indicator" - creates it if necessary
1707      */
1708     public ID getStf29_ReActivationApprovalIndicator() { 
1709 		ID retVal = this.getTypedField(29, 0);
1710 		return retVal;
1711     }
1712 
1713 
1714     /**
1715      * Returns all repetitions of Citizenship (STF-30).
1716      */
1717     public CWE[] getCitizenship() {
1718     	CWE[] retVal = this.getTypedField(30, new CWE[0]);
1719     	return retVal;
1720     }
1721 
1722 
1723     /**
1724      * Returns all repetitions of Citizenship (STF-30).
1725      */
1726     public CWE[] getStf30_Citizenship() {
1727     	CWE[] retVal = this.getTypedField(30, new CWE[0]);
1728     	return retVal;
1729     }
1730 
1731 
1732     /**
1733      * Returns a count of the current number of repetitions of Citizenship (STF-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 getCitizenshipReps() {
1738     	return this.getReps(30);
1739     }
1740 
1741 
1742     /**
1743      * Returns a specific repetition of
1744      * STF-30: "Citizenship" - creates it if necessary
1745      *
1746      * @param rep The repetition index (0-indexed)
1747      */
1748     public CWE getCitizenship(int rep) { 
1749 		CWE retVal = this.getTypedField(30, rep);
1750 		return retVal;
1751     }
1752 
1753     /**
1754      * Returns a specific repetition of
1755      * STF-30: "Citizenship" - creates it if necessary
1756      *
1757      * @param rep The repetition index (0-indexed)
1758      */
1759     public CWE getStf30_Citizenship(int rep) { 
1760 		CWE retVal = this.getTypedField(30, rep);
1761 		return retVal;
1762     }
1763 
1764     /**
1765      * Returns a count of the current number of repetitions of Citizenship (STF-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 getStf30_CitizenshipReps() {
1770     	return this.getReps(30);
1771     }
1772 
1773 
1774     /**
1775      * Inserts a repetition of
1776      * STF-30: "Citizenship" 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 CWE insertCitizenship(int rep) throws HL7Exception { 
1782         return (CWE) super.insertRepetition(30, rep);
1783     }
1784 
1785 
1786     /**
1787      * Inserts a repetition of
1788      * STF-30: "Citizenship" 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 CWE insertStf30_Citizenship(int rep) throws HL7Exception { 
1794         return (CWE) super.insertRepetition(30, rep);
1795     }
1796 
1797 
1798     /**
1799      * Removes a repetition of
1800      * STF-30: "Citizenship" 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 CWE removeCitizenship(int rep) throws HL7Exception { 
1806         return (CWE) super.removeRepetition(30, rep);
1807     }
1808 
1809 
1810     /**
1811      * Removes a repetition of
1812      * STF-30: "Citizenship" 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 CWE removeStf30_Citizenship(int rep) throws HL7Exception { 
1818         return (CWE) super.removeRepetition(30, rep);
1819     }
1820 
1821 
1822 
1823 
1824     /**
1825      * Returns
1826      * STF-31: "Date/Time of Death" - creates it if necessary
1827      */
1828     public DTM getDateTimeOfDeath() { 
1829 		DTM retVal = this.getTypedField(31, 0);
1830 		return retVal;
1831     }
1832     
1833     /**
1834      * Returns
1835      * STF-31: "Date/Time of Death" - creates it if necessary
1836      */
1837     public DTM getStf31_DateTimeOfDeath() { 
1838 		DTM retVal = this.getTypedField(31, 0);
1839 		return retVal;
1840     }
1841 
1842 
1843 
1844     /**
1845      * Returns
1846      * STF-32: "Death Indicator" - creates it if necessary
1847      */
1848     public ID getDeathIndicator() { 
1849 		ID retVal = this.getTypedField(32, 0);
1850 		return retVal;
1851     }
1852     
1853     /**
1854      * Returns
1855      * STF-32: "Death Indicator" - creates it if necessary
1856      */
1857     public ID getStf32_DeathIndicator() { 
1858 		ID retVal = this.getTypedField(32, 0);
1859 		return retVal;
1860     }
1861 
1862 
1863 
1864     /**
1865      * Returns
1866      * STF-33: "Institution Relationship Type Code" - creates it if necessary
1867      */
1868     public CWE getInstitutionRelationshipTypeCode() { 
1869 		CWE retVal = this.getTypedField(33, 0);
1870 		return retVal;
1871     }
1872     
1873     /**
1874      * Returns
1875      * STF-33: "Institution Relationship Type Code" - creates it if necessary
1876      */
1877     public CWE getStf33_InstitutionRelationshipTypeCode() { 
1878 		CWE retVal = this.getTypedField(33, 0);
1879 		return retVal;
1880     }
1881 
1882 
1883 
1884     /**
1885      * Returns
1886      * STF-34: "Institution Relationship Period" - creates it if necessary
1887      */
1888     public DR getInstitutionRelationshipPeriod() { 
1889 		DR retVal = this.getTypedField(34, 0);
1890 		return retVal;
1891     }
1892     
1893     /**
1894      * Returns
1895      * STF-34: "Institution Relationship Period" - creates it if necessary
1896      */
1897     public DR getStf34_InstitutionRelationshipPeriod() { 
1898 		DR retVal = this.getTypedField(34, 0);
1899 		return retVal;
1900     }
1901 
1902 
1903 
1904     /**
1905      * Returns
1906      * STF-35: "Expected Return Date" - creates it if necessary
1907      */
1908     public DT getExpectedReturnDate() { 
1909 		DT retVal = this.getTypedField(35, 0);
1910 		return retVal;
1911     }
1912     
1913     /**
1914      * Returns
1915      * STF-35: "Expected Return Date" - creates it if necessary
1916      */
1917     public DT getStf35_ExpectedReturnDate() { 
1918 		DT retVal = this.getTypedField(35, 0);
1919 		return retVal;
1920     }
1921 
1922 
1923     /**
1924      * Returns all repetitions of Cost Center Code (STF-36).
1925      */
1926     public CWE[] getCostCenterCode() {
1927     	CWE[] retVal = this.getTypedField(36, new CWE[0]);
1928     	return retVal;
1929     }
1930 
1931 
1932     /**
1933      * Returns all repetitions of Cost Center Code (STF-36).
1934      */
1935     public CWE[] getStf36_CostCenterCode() {
1936     	CWE[] retVal = this.getTypedField(36, new CWE[0]);
1937     	return retVal;
1938     }
1939 
1940 
1941     /**
1942      * Returns a count of the current number of repetitions of Cost Center Code (STF-36).
1943      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1944      * it will return zero.
1945      */
1946     public int getCostCenterCodeReps() {
1947     	return this.getReps(36);
1948     }
1949 
1950 
1951     /**
1952      * Returns a specific repetition of
1953      * STF-36: "Cost Center Code" - creates it if necessary
1954      *
1955      * @param rep The repetition index (0-indexed)
1956      */
1957     public CWE getCostCenterCode(int rep) { 
1958 		CWE retVal = this.getTypedField(36, rep);
1959 		return retVal;
1960     }
1961 
1962     /**
1963      * Returns a specific repetition of
1964      * STF-36: "Cost Center Code" - creates it if necessary
1965      *
1966      * @param rep The repetition index (0-indexed)
1967      */
1968     public CWE getStf36_CostCenterCode(int rep) { 
1969 		CWE retVal = this.getTypedField(36, rep);
1970 		return retVal;
1971     }
1972 
1973     /**
1974      * Returns a count of the current number of repetitions of Cost Center Code (STF-36).
1975      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1976      * it will return zero.
1977      */
1978     public int getStf36_CostCenterCodeReps() {
1979     	return this.getReps(36);
1980     }
1981 
1982 
1983     /**
1984      * Inserts a repetition of
1985      * STF-36: "Cost Center Code" at a specific index
1986      *
1987      * @param rep The repetition index (0-indexed)
1988      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1989      */
1990     public CWE insertCostCenterCode(int rep) throws HL7Exception { 
1991         return (CWE) super.insertRepetition(36, rep);
1992     }
1993 
1994 
1995     /**
1996      * Inserts a repetition of
1997      * STF-36: "Cost Center Code" at a specific index
1998      *
1999      * @param rep The repetition index (0-indexed)
2000      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2001      */
2002     public CWE insertStf36_CostCenterCode(int rep) throws HL7Exception { 
2003         return (CWE) super.insertRepetition(36, rep);
2004     }
2005 
2006 
2007     /**
2008      * Removes a repetition of
2009      * STF-36: "Cost Center Code" at a specific index
2010      *
2011      * @param rep The repetition index (0-indexed)
2012      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2013      */
2014     public CWE removeCostCenterCode(int rep) throws HL7Exception { 
2015         return (CWE) super.removeRepetition(36, rep);
2016     }
2017 
2018 
2019     /**
2020      * Removes a repetition of
2021      * STF-36: "Cost Center Code" at a specific index
2022      *
2023      * @param rep The repetition index (0-indexed)
2024      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2025      */
2026     public CWE removeStf36_CostCenterCode(int rep) throws HL7Exception { 
2027         return (CWE) super.removeRepetition(36, rep);
2028     }
2029 
2030 
2031 
2032 
2033     /**
2034      * Returns
2035      * STF-37: "Generic Classification Indicator" - creates it if necessary
2036      */
2037     public ID getGenericClassificationIndicator() { 
2038 		ID retVal = this.getTypedField(37, 0);
2039 		return retVal;
2040     }
2041     
2042     /**
2043      * Returns
2044      * STF-37: "Generic Classification Indicator" - creates it if necessary
2045      */
2046     public ID getStf37_GenericClassificationIndicator() { 
2047 		ID retVal = this.getTypedField(37, 0);
2048 		return retVal;
2049     }
2050 
2051 
2052 
2053     /**
2054      * Returns
2055      * STF-38: "Inactive Reason Code" - creates it if necessary
2056      */
2057     public CWE getInactiveReasonCode() { 
2058 		CWE retVal = this.getTypedField(38, 0);
2059 		return retVal;
2060     }
2061     
2062     /**
2063      * Returns
2064      * STF-38: "Inactive Reason Code" - creates it if necessary
2065      */
2066     public CWE getStf38_InactiveReasonCode() { 
2067 		CWE retVal = this.getTypedField(38, 0);
2068 		return retVal;
2069     }
2070 
2071 
2072     /**
2073      * Returns all repetitions of Generic resource type or category (STF-39).
2074      */
2075     public CWE[] getGenericResourceTypeOrCategory() {
2076     	CWE[] retVal = this.getTypedField(39, new CWE[0]);
2077     	return retVal;
2078     }
2079 
2080 
2081     /**
2082      * Returns all repetitions of Generic resource type or category (STF-39).
2083      */
2084     public CWE[] getStf39_GenericResourceTypeOrCategory() {
2085     	CWE[] retVal = this.getTypedField(39, new CWE[0]);
2086     	return retVal;
2087     }
2088 
2089 
2090     /**
2091      * Returns a count of the current number of repetitions of Generic resource type or category (STF-39).
2092      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2093      * it will return zero.
2094      */
2095     public int getGenericResourceTypeOrCategoryReps() {
2096     	return this.getReps(39);
2097     }
2098 
2099 
2100     /**
2101      * Returns a specific repetition of
2102      * STF-39: "Generic resource type or category" - creates it if necessary
2103      *
2104      * @param rep The repetition index (0-indexed)
2105      */
2106     public CWE getGenericResourceTypeOrCategory(int rep) { 
2107 		CWE retVal = this.getTypedField(39, rep);
2108 		return retVal;
2109     }
2110 
2111     /**
2112      * Returns a specific repetition of
2113      * STF-39: "Generic resource type or category" - creates it if necessary
2114      *
2115      * @param rep The repetition index (0-indexed)
2116      */
2117     public CWE getStf39_GenericResourceTypeOrCategory(int rep) { 
2118 		CWE retVal = this.getTypedField(39, rep);
2119 		return retVal;
2120     }
2121 
2122     /**
2123      * Returns a count of the current number of repetitions of Generic resource type or category (STF-39).
2124      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
2125      * it will return zero.
2126      */
2127     public int getStf39_GenericResourceTypeOrCategoryReps() {
2128     	return this.getReps(39);
2129     }
2130 
2131 
2132     /**
2133      * Inserts a repetition of
2134      * STF-39: "Generic resource type or category" at a specific index
2135      *
2136      * @param rep The repetition index (0-indexed)
2137      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2138      */
2139     public CWE insertGenericResourceTypeOrCategory(int rep) throws HL7Exception { 
2140         return (CWE) super.insertRepetition(39, rep);
2141     }
2142 
2143 
2144     /**
2145      * Inserts a repetition of
2146      * STF-39: "Generic resource type or category" at a specific index
2147      *
2148      * @param rep The repetition index (0-indexed)
2149      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2150      */
2151     public CWE insertStf39_GenericResourceTypeOrCategory(int rep) throws HL7Exception { 
2152         return (CWE) super.insertRepetition(39, rep);
2153     }
2154 
2155 
2156     /**
2157      * Removes a repetition of
2158      * STF-39: "Generic resource type or category" at a specific index
2159      *
2160      * @param rep The repetition index (0-indexed)
2161      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2162      */
2163     public CWE removeGenericResourceTypeOrCategory(int rep) throws HL7Exception { 
2164         return (CWE) super.removeRepetition(39, rep);
2165     }
2166 
2167 
2168     /**
2169      * Removes a repetition of
2170      * STF-39: "Generic resource type or category" at a specific index
2171      *
2172      * @param rep The repetition index (0-indexed)
2173      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
2174      */
2175     public CWE removeStf39_GenericResourceTypeOrCategory(int rep) throws HL7Exception { 
2176         return (CWE) super.removeRepetition(39, rep);
2177     }
2178 
2179 
2180 
2181 
2182     /**
2183      * Returns
2184      * STF-40: "Religion" - creates it if necessary
2185      */
2186     public CWE getReligion() { 
2187 		CWE retVal = this.getTypedField(40, 0);
2188 		return retVal;
2189     }
2190     
2191     /**
2192      * Returns
2193      * STF-40: "Religion" - creates it if necessary
2194      */
2195     public CWE getStf40_Religion() { 
2196 		CWE retVal = this.getTypedField(40, 0);
2197 		return retVal;
2198     }
2199 
2200 
2201 
2202     /**
2203      * Returns
2204      * STF-41: "Signature" - creates it if necessary
2205      */
2206     public ED getSignature() { 
2207 		ED retVal = this.getTypedField(41, 0);
2208 		return retVal;
2209     }
2210     
2211     /**
2212      * Returns
2213      * STF-41: "Signature" - creates it if necessary
2214      */
2215     public ED getStf41_Signature() { 
2216 		ED retVal = this.getTypedField(41, 0);
2217 		return retVal;
2218     }
2219 
2220 
2221 
2222 
2223 
2224     /** {@inheritDoc} */   
2225     protected Type createNewTypeWithoutReflection(int field) {
2226        switch (field) {
2227           case 0: return new CWE(getMessage());
2228           case 1: return new CX(getMessage());
2229           case 2: return new XPN(getMessage());
2230           case 3: return new CWE(getMessage());
2231           case 4: return new CWE(getMessage());
2232           case 5: return new DTM(getMessage());
2233           case 6: return new ID(getMessage(), new Integer( 183 ));
2234           case 7: return new CWE(getMessage());
2235           case 8: return new CWE(getMessage());
2236           case 9: return new XTN(getMessage());
2237           case 10: return new XAD(getMessage());
2238           case 11: return new DIN(getMessage());
2239           case 12: return new DIN(getMessage());
2240           case 13: return new CWE(getMessage());
2241           case 14: return new ST(getMessage());
2242           case 15: return new CWE(getMessage());
2243           case 16: return new CWE(getMessage());
2244           case 17: return new ST(getMessage());
2245           case 18: return new JCC(getMessage());
2246           case 19: return new CWE(getMessage());
2247           case 20: return new ID(getMessage(), new Integer( 136 ));
2248           case 21: return new DLN(getMessage());
2249           case 22: return new ID(getMessage(), new Integer( 136 ));
2250           case 23: return new DT(getMessage());
2251           case 24: return new DT(getMessage());
2252           case 25: return new DT(getMessage());
2253           case 26: return new CWE(getMessage());
2254           case 27: return new CWE(getMessage());
2255           case 28: return new ID(getMessage(), new Integer( 136 ));
2256           case 29: return new CWE(getMessage());
2257           case 30: return new DTM(getMessage());
2258           case 31: return new ID(getMessage(), new Integer( 136 ));
2259           case 32: return new CWE(getMessage());
2260           case 33: return new DR(getMessage());
2261           case 34: return new DT(getMessage());
2262           case 35: return new CWE(getMessage());
2263           case 36: return new ID(getMessage(), new Integer( 136 ));
2264           case 37: return new CWE(getMessage());
2265           case 38: return new CWE(getMessage());
2266           case 39: return new CWE(getMessage());
2267           case 40: return new ED(getMessage());
2268           default: return null;
2269        }
2270    }
2271 
2272 
2273 }
2274