View Javadoc
1   /*
2    * This class is an auto-generated source file for a HAPI
3    * HL7 v2.x standard structure class.
4    *
5    * For more information, visit: http://hl7api.sourceforge.net/
6    * 
7    * The contents of this file are subject to the Mozilla Public License Version 1.1 
8    * (the "License"); you may not use this file except in compliance with the License. 
9    * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
10   * Software distributed under the License is distributed on an "AS IS" basis, 
11   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
12   * specific language governing rights and limitations under the License. 
13   * 
14   * The Original Code is "[file_name]".  Description: 
15   * "[one_line_description]" 
16   * 
17   * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
18   * 2012.  All Rights Reserved. 
19   * 
20   * Contributor(s): ______________________________________. 
21   * 
22   * Alternatively, the contents of this file may be used under the terms of the 
23   * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
24   * applicable instead of those above.  If you wish to allow use of your version of this 
25   * file only under the terms of the GPL and not to allow others to use your version 
26   * of this file under the MPL, indicate your decision by deleting  the provisions above 
27   * and replace  them with the notice and other provisions required by the GPL License.  
28   * If you do not delete the provisions above, a recipient may use your version of 
29   * this file under either the MPL or the GPL. 
30   * 
31   */
32  
33  
34  package ca.uhn.hl7v2.model.v25.segment;
35  
36  // import ca.uhn.hl7v2.model.v25.group.*;
37  import ca.uhn.hl7v2.model.v25.datatype.*;
38  import ca.uhn.hl7v2.HL7Exception;
39  import ca.uhn.hl7v2.parser.ModelClassFactory;
40  import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
41  import ca.uhn.hl7v2.model.AbstractMessage;
42  import ca.uhn.hl7v2.model.Group;
43  import ca.uhn.hl7v2.model.Type;
44  import ca.uhn.hl7v2.model.AbstractSegment;
45  import ca.uhn.hl7v2.model.Varies;
46  
47  
48  /**
49   *<p>Represents an HL7 FT1 message segment (Financial Transaction). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>FT1-1: Set ID - FT1 (SI) <b>optional </b>
53       * <li>FT1-2: Transaction ID (ST) <b>optional </b>
54       * <li>FT1-3: Transaction Batch ID (ST) <b>optional </b>
55       * <li>FT1-4: Transaction Date (DR) <b> </b>
56       * <li>FT1-5: Transaction Posting Date (TS) <b>optional </b>
57       * <li>FT1-6: Transaction Type (IS) <b> </b>
58       * <li>FT1-7: Transaction Code (CE) <b> </b>
59       * <li>FT1-8: Transaction Description (ST) <b>optional </b>
60       * <li>FT1-9: Transaction Description - Alt (ST) <b>optional </b>
61       * <li>FT1-10: Transaction Quantity (NM) <b>optional </b>
62       * <li>FT1-11: Transaction Amount - Extended (CP) <b>optional </b>
63       * <li>FT1-12: Transaction Amount - Unit (CP) <b>optional </b>
64       * <li>FT1-13: Department Code (CE) <b>optional </b>
65       * <li>FT1-14: Insurance Plan ID (CE) <b>optional </b>
66       * <li>FT1-15: Insurance Amount (CP) <b>optional </b>
67       * <li>FT1-16: Assigned Patient Location (PL) <b>optional </b>
68       * <li>FT1-17: Fee Schedule (IS) <b>optional </b>
69       * <li>FT1-18: Patient Type (IS) <b>optional </b>
70       * <li>FT1-19: Diagnosis Code - FT1 (CE) <b>optional repeating</b>
71       * <li>FT1-20: Performed By Code (XCN) <b>optional repeating</b>
72       * <li>FT1-21: Ordered By Code (XCN) <b>optional repeating</b>
73       * <li>FT1-22: Unit Cost (CP) <b>optional </b>
74       * <li>FT1-23: Filler Order Number (EI) <b>optional </b>
75       * <li>FT1-24: Entered By Code (XCN) <b>optional repeating</b>
76       * <li>FT1-25: Procedure Code (CE) <b>optional </b>
77       * <li>FT1-26: Procedure Code Modifier (CE) <b>optional repeating</b>
78       * <li>FT1-27: Advanced Beneficiary Notice Code (CE) <b>optional </b>
79       * <li>FT1-28: Medically Necessary Duplicate Procedure Reason. (CWE) <b>optional </b>
80       * <li>FT1-29: NDC Code (CNE) <b>optional </b>
81       * <li>FT1-30: Payment Reference ID (CX) <b>optional </b>
82       * <li>FT1-31: Transaction Reference Key (SI) <b>optional repeating</b>
83   * </ul>
84   */
85  @SuppressWarnings("unused")
86  public class FT1 extends AbstractSegment {
87  
88      /** 
89       * Creates a new FT1 segment
90       */
91      public FT1(Group parent, ModelClassFactory factory) {
92         super(parent, factory);
93         init(factory);
94      }
95  
96      private void init(ModelClassFactory factory) {
97         try {
98                                    this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - FT1");
99                                    this.add(ST.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction ID");
100                                   this.add(ST.class, false, 1, 10, new Object[]{ getMessage() }, "Transaction Batch ID");
101                                   this.add(DR.class, true, 1, 53, new Object[]{ getMessage() }, "Transaction Date");
102                                   this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Transaction Posting Date");
103                                               this.add(IS.class, true, 1, 8, new Object[]{ getMessage(), new Integer(17) }, "Transaction Type");
104                                   this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Transaction Code");
105                                   this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Transaction Description");
106                                   this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Transaction Description - Alt");
107                                   this.add(NM.class, false, 1, 6, new Object[]{ getMessage() }, "Transaction Quantity");
108                                   this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction Amount - Extended");
109                                   this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction Amount - Unit");
110                                   this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Department Code");
111                                   this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Insurance Plan ID");
112                                   this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Insurance Amount");
113                                   this.add(PL.class, false, 1, 80, new Object[]{ getMessage() }, "Assigned Patient Location");
114                                               this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(24) }, "Fee Schedule");
115                                               this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(18) }, "Patient Type");
116                                   this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Diagnosis Code - FT1");
117                                   this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Performed By Code");
118                                   this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Ordered By Code");
119                                   this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Unit Cost");
120                                   this.add(EI.class, false, 1, 22, new Object[]{ getMessage() }, "Filler Order Number");
121                                   this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Entered By Code");
122                                   this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Procedure Code");
123                                   this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Code Modifier");
124                                   this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Advanced Beneficiary Notice Code");
125                                   this.add(CWE.class, false, 1, 250, new Object[]{ getMessage() }, "Medically Necessary Duplicate Procedure Reason.");
126                                   this.add(CNE.class, false, 1, 250, new Object[]{ getMessage() }, "NDC Code");
127                                   this.add(CX.class, false, 1, 250, new Object[]{ getMessage() }, "Payment Reference ID");
128                                   this.add(SI.class, false, 0, 4, new Object[]{ getMessage() }, "Transaction Reference Key");
129        } catch(HL7Exception e) {
130           log.error("Unexpected error creating FT1 - this is probably a bug in the source code generator.", e);
131        }
132     }
133 
134 
135 
136     /**
137      * Returns
138      * FT1-1: "Set ID - FT1" - creates it if necessary
139      */
140     public SI getSetIDFT1() { 
141 		SI retVal = this.getTypedField(1, 0);
142 		return retVal;
143     }
144     
145     /**
146      * Returns
147      * FT1-1: "Set ID - FT1" - creates it if necessary
148      */
149     public SI getFt11_SetIDFT1() { 
150 		SI retVal = this.getTypedField(1, 0);
151 		return retVal;
152     }
153 
154 
155 
156     /**
157      * Returns
158      * FT1-2: "Transaction ID" - creates it if necessary
159      */
160     public ST getTransactionID() { 
161 		ST retVal = this.getTypedField(2, 0);
162 		return retVal;
163     }
164     
165     /**
166      * Returns
167      * FT1-2: "Transaction ID" - creates it if necessary
168      */
169     public ST getFt12_TransactionID() { 
170 		ST retVal = this.getTypedField(2, 0);
171 		return retVal;
172     }
173 
174 
175 
176     /**
177      * Returns
178      * FT1-3: "Transaction Batch ID" - creates it if necessary
179      */
180     public ST getTransactionBatchID() { 
181 		ST retVal = this.getTypedField(3, 0);
182 		return retVal;
183     }
184     
185     /**
186      * Returns
187      * FT1-3: "Transaction Batch ID" - creates it if necessary
188      */
189     public ST getFt13_TransactionBatchID() { 
190 		ST retVal = this.getTypedField(3, 0);
191 		return retVal;
192     }
193 
194 
195 
196     /**
197      * Returns
198      * FT1-4: "Transaction Date" - creates it if necessary
199      */
200     public DR getTransactionDate() { 
201 		DR retVal = this.getTypedField(4, 0);
202 		return retVal;
203     }
204     
205     /**
206      * Returns
207      * FT1-4: "Transaction Date" - creates it if necessary
208      */
209     public DR getFt14_TransactionDate() { 
210 		DR retVal = this.getTypedField(4, 0);
211 		return retVal;
212     }
213 
214 
215 
216     /**
217      * Returns
218      * FT1-5: "Transaction Posting Date" - creates it if necessary
219      */
220     public TS getTransactionPostingDate() { 
221 		TS retVal = this.getTypedField(5, 0);
222 		return retVal;
223     }
224     
225     /**
226      * Returns
227      * FT1-5: "Transaction Posting Date" - creates it if necessary
228      */
229     public TS getFt15_TransactionPostingDate() { 
230 		TS retVal = this.getTypedField(5, 0);
231 		return retVal;
232     }
233 
234 
235 
236     /**
237      * Returns
238      * FT1-6: "Transaction Type" - creates it if necessary
239      */
240     public IS getTransactionType() { 
241 		IS retVal = this.getTypedField(6, 0);
242 		return retVal;
243     }
244     
245     /**
246      * Returns
247      * FT1-6: "Transaction Type" - creates it if necessary
248      */
249     public IS getFt16_TransactionType() { 
250 		IS retVal = this.getTypedField(6, 0);
251 		return retVal;
252     }
253 
254 
255 
256     /**
257      * Returns
258      * FT1-7: "Transaction Code" - creates it if necessary
259      */
260     public CE getTransactionCode() { 
261 		CE retVal = this.getTypedField(7, 0);
262 		return retVal;
263     }
264     
265     /**
266      * Returns
267      * FT1-7: "Transaction Code" - creates it if necessary
268      */
269     public CE getFt17_TransactionCode() { 
270 		CE retVal = this.getTypedField(7, 0);
271 		return retVal;
272     }
273 
274 
275 
276     /**
277      * Returns
278      * FT1-8: "Transaction Description" - creates it if necessary
279      */
280     public ST getTransactionDescription() { 
281 		ST retVal = this.getTypedField(8, 0);
282 		return retVal;
283     }
284     
285     /**
286      * Returns
287      * FT1-8: "Transaction Description" - creates it if necessary
288      */
289     public ST getFt18_TransactionDescription() { 
290 		ST retVal = this.getTypedField(8, 0);
291 		return retVal;
292     }
293 
294 
295 
296     /**
297      * Returns
298      * FT1-9: "Transaction Description - Alt" - creates it if necessary
299      */
300     public ST getTransactionDescriptionAlt() { 
301 		ST retVal = this.getTypedField(9, 0);
302 		return retVal;
303     }
304     
305     /**
306      * Returns
307      * FT1-9: "Transaction Description - Alt" - creates it if necessary
308      */
309     public ST getFt19_TransactionDescriptionAlt() { 
310 		ST retVal = this.getTypedField(9, 0);
311 		return retVal;
312     }
313 
314 
315 
316     /**
317      * Returns
318      * FT1-10: "Transaction Quantity" - creates it if necessary
319      */
320     public NM getTransactionQuantity() { 
321 		NM retVal = this.getTypedField(10, 0);
322 		return retVal;
323     }
324     
325     /**
326      * Returns
327      * FT1-10: "Transaction Quantity" - creates it if necessary
328      */
329     public NM getFt110_TransactionQuantity() { 
330 		NM retVal = this.getTypedField(10, 0);
331 		return retVal;
332     }
333 
334 
335 
336     /**
337      * Returns
338      * FT1-11: "Transaction Amount - Extended" - creates it if necessary
339      */
340     public CP getTransactionAmountExtended() { 
341 		CP retVal = this.getTypedField(11, 0);
342 		return retVal;
343     }
344     
345     /**
346      * Returns
347      * FT1-11: "Transaction Amount - Extended" - creates it if necessary
348      */
349     public CP getFt111_TransactionAmountExtended() { 
350 		CP retVal = this.getTypedField(11, 0);
351 		return retVal;
352     }
353 
354 
355 
356     /**
357      * Returns
358      * FT1-12: "Transaction Amount - Unit" - creates it if necessary
359      */
360     public CP getTransactionAmountUnit() { 
361 		CP retVal = this.getTypedField(12, 0);
362 		return retVal;
363     }
364     
365     /**
366      * Returns
367      * FT1-12: "Transaction Amount - Unit" - creates it if necessary
368      */
369     public CP getFt112_TransactionAmountUnit() { 
370 		CP retVal = this.getTypedField(12, 0);
371 		return retVal;
372     }
373 
374 
375 
376     /**
377      * Returns
378      * FT1-13: "Department Code" - creates it if necessary
379      */
380     public CE getDepartmentCode() { 
381 		CE retVal = this.getTypedField(13, 0);
382 		return retVal;
383     }
384     
385     /**
386      * Returns
387      * FT1-13: "Department Code" - creates it if necessary
388      */
389     public CE getFt113_DepartmentCode() { 
390 		CE retVal = this.getTypedField(13, 0);
391 		return retVal;
392     }
393 
394 
395 
396     /**
397      * Returns
398      * FT1-14: "Insurance Plan ID" - creates it if necessary
399      */
400     public CE getInsurancePlanID() { 
401 		CE retVal = this.getTypedField(14, 0);
402 		return retVal;
403     }
404     
405     /**
406      * Returns
407      * FT1-14: "Insurance Plan ID" - creates it if necessary
408      */
409     public CE getFt114_InsurancePlanID() { 
410 		CE retVal = this.getTypedField(14, 0);
411 		return retVal;
412     }
413 
414 
415 
416     /**
417      * Returns
418      * FT1-15: "Insurance Amount" - creates it if necessary
419      */
420     public CP getInsuranceAmount() { 
421 		CP retVal = this.getTypedField(15, 0);
422 		return retVal;
423     }
424     
425     /**
426      * Returns
427      * FT1-15: "Insurance Amount" - creates it if necessary
428      */
429     public CP getFt115_InsuranceAmount() { 
430 		CP retVal = this.getTypedField(15, 0);
431 		return retVal;
432     }
433 
434 
435 
436     /**
437      * Returns
438      * FT1-16: "Assigned Patient Location" - creates it if necessary
439      */
440     public PL getAssignedPatientLocation() { 
441 		PL retVal = this.getTypedField(16, 0);
442 		return retVal;
443     }
444     
445     /**
446      * Returns
447      * FT1-16: "Assigned Patient Location" - creates it if necessary
448      */
449     public PL getFt116_AssignedPatientLocation() { 
450 		PL retVal = this.getTypedField(16, 0);
451 		return retVal;
452     }
453 
454 
455 
456     /**
457      * Returns
458      * FT1-17: "Fee Schedule" - creates it if necessary
459      */
460     public IS getFeeSchedule() { 
461 		IS retVal = this.getTypedField(17, 0);
462 		return retVal;
463     }
464     
465     /**
466      * Returns
467      * FT1-17: "Fee Schedule" - creates it if necessary
468      */
469     public IS getFt117_FeeSchedule() { 
470 		IS retVal = this.getTypedField(17, 0);
471 		return retVal;
472     }
473 
474 
475 
476     /**
477      * Returns
478      * FT1-18: "Patient Type" - creates it if necessary
479      */
480     public IS getPatientType() { 
481 		IS retVal = this.getTypedField(18, 0);
482 		return retVal;
483     }
484     
485     /**
486      * Returns
487      * FT1-18: "Patient Type" - creates it if necessary
488      */
489     public IS getFt118_PatientType() { 
490 		IS retVal = this.getTypedField(18, 0);
491 		return retVal;
492     }
493 
494 
495     /**
496      * Returns all repetitions of Diagnosis Code - FT1 (FT1-19).
497      */
498     public CE[] getDiagnosisCodeFT1() {
499     	CE[] retVal = this.getTypedField(19, new CE[0]);
500     	return retVal;
501     }
502 
503 
504     /**
505      * Returns all repetitions of Diagnosis Code - FT1 (FT1-19).
506      */
507     public CE[] getFt119_DiagnosisCodeFT1() {
508     	CE[] retVal = this.getTypedField(19, new CE[0]);
509     	return retVal;
510     }
511 
512 
513     /**
514      * Returns a count of the current number of repetitions of Diagnosis Code - FT1 (FT1-19).
515      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
516      * it will return zero.
517      */
518     public int getDiagnosisCodeFT1Reps() {
519     	return this.getReps(19);
520     }
521 
522 
523     /**
524      * Returns a specific repetition of
525      * FT1-19: "Diagnosis Code - FT1" - creates it if necessary
526      *
527      * @param rep The repetition index (0-indexed)
528      */
529     public CE getDiagnosisCodeFT1(int rep) { 
530 		CE retVal = this.getTypedField(19, rep);
531 		return retVal;
532     }
533 
534     /**
535      * Returns a specific repetition of
536      * FT1-19: "Diagnosis Code - FT1" - creates it if necessary
537      *
538      * @param rep The repetition index (0-indexed)
539      */
540     public CE getFt119_DiagnosisCodeFT1(int rep) { 
541 		CE retVal = this.getTypedField(19, rep);
542 		return retVal;
543     }
544 
545     /**
546      * Returns a count of the current number of repetitions of Diagnosis Code - FT1 (FT1-19).
547      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
548      * it will return zero.
549      */
550     public int getFt119_DiagnosisCodeFT1Reps() {
551     	return this.getReps(19);
552     }
553 
554 
555     /**
556      * Inserts a repetition of
557      * FT1-19: "Diagnosis Code - FT1" at a specific index
558      *
559      * @param rep The repetition index (0-indexed)
560      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
561      */
562     public CE insertDiagnosisCodeFT1(int rep) throws HL7Exception { 
563         return (CE) super.insertRepetition(19, rep);
564     }
565 
566 
567     /**
568      * Inserts a repetition of
569      * FT1-19: "Diagnosis Code - FT1" at a specific index
570      *
571      * @param rep The repetition index (0-indexed)
572      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
573      */
574     public CE insertFt119_DiagnosisCodeFT1(int rep) throws HL7Exception { 
575         return (CE) super.insertRepetition(19, rep);
576     }
577 
578 
579     /**
580      * Removes a repetition of
581      * FT1-19: "Diagnosis Code - FT1" at a specific index
582      *
583      * @param rep The repetition index (0-indexed)
584      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
585      */
586     public CE removeDiagnosisCodeFT1(int rep) throws HL7Exception { 
587         return (CE) super.removeRepetition(19, rep);
588     }
589 
590 
591     /**
592      * Removes a repetition of
593      * FT1-19: "Diagnosis Code - FT1" at a specific index
594      *
595      * @param rep The repetition index (0-indexed)
596      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
597      */
598     public CE removeFt119_DiagnosisCodeFT1(int rep) throws HL7Exception { 
599         return (CE) super.removeRepetition(19, rep);
600     }
601 
602 
603 
604     /**
605      * Returns all repetitions of Performed By Code (FT1-20).
606      */
607     public XCN[] getPerformedByCode() {
608     	XCN[] retVal = this.getTypedField(20, new XCN[0]);
609     	return retVal;
610     }
611 
612 
613     /**
614      * Returns all repetitions of Performed By Code (FT1-20).
615      */
616     public XCN[] getFt120_PerformedByCode() {
617     	XCN[] retVal = this.getTypedField(20, new XCN[0]);
618     	return retVal;
619     }
620 
621 
622     /**
623      * Returns a count of the current number of repetitions of Performed By Code (FT1-20).
624      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
625      * it will return zero.
626      */
627     public int getPerformedByCodeReps() {
628     	return this.getReps(20);
629     }
630 
631 
632     /**
633      * Returns a specific repetition of
634      * FT1-20: "Performed By Code" - creates it if necessary
635      *
636      * @param rep The repetition index (0-indexed)
637      */
638     public XCN getPerformedByCode(int rep) { 
639 		XCN retVal = this.getTypedField(20, rep);
640 		return retVal;
641     }
642 
643     /**
644      * Returns a specific repetition of
645      * FT1-20: "Performed By Code" - creates it if necessary
646      *
647      * @param rep The repetition index (0-indexed)
648      */
649     public XCN getFt120_PerformedByCode(int rep) { 
650 		XCN retVal = this.getTypedField(20, rep);
651 		return retVal;
652     }
653 
654     /**
655      * Returns a count of the current number of repetitions of Performed By Code (FT1-20).
656      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
657      * it will return zero.
658      */
659     public int getFt120_PerformedByCodeReps() {
660     	return this.getReps(20);
661     }
662 
663 
664     /**
665      * Inserts a repetition of
666      * FT1-20: "Performed By Code" at a specific index
667      *
668      * @param rep The repetition index (0-indexed)
669      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
670      */
671     public XCN insertPerformedByCode(int rep) throws HL7Exception { 
672         return (XCN) super.insertRepetition(20, rep);
673     }
674 
675 
676     /**
677      * Inserts a repetition of
678      * FT1-20: "Performed By Code" at a specific index
679      *
680      * @param rep The repetition index (0-indexed)
681      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
682      */
683     public XCN insertFt120_PerformedByCode(int rep) throws HL7Exception { 
684         return (XCN) super.insertRepetition(20, rep);
685     }
686 
687 
688     /**
689      * Removes a repetition of
690      * FT1-20: "Performed By Code" at a specific index
691      *
692      * @param rep The repetition index (0-indexed)
693      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
694      */
695     public XCN removePerformedByCode(int rep) throws HL7Exception { 
696         return (XCN) super.removeRepetition(20, rep);
697     }
698 
699 
700     /**
701      * Removes a repetition of
702      * FT1-20: "Performed By Code" at a specific index
703      *
704      * @param rep The repetition index (0-indexed)
705      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
706      */
707     public XCN removeFt120_PerformedByCode(int rep) throws HL7Exception { 
708         return (XCN) super.removeRepetition(20, rep);
709     }
710 
711 
712 
713     /**
714      * Returns all repetitions of Ordered By Code (FT1-21).
715      */
716     public XCN[] getOrderedByCode() {
717     	XCN[] retVal = this.getTypedField(21, new XCN[0]);
718     	return retVal;
719     }
720 
721 
722     /**
723      * Returns all repetitions of Ordered By Code (FT1-21).
724      */
725     public XCN[] getFt121_OrderedByCode() {
726     	XCN[] retVal = this.getTypedField(21, new XCN[0]);
727     	return retVal;
728     }
729 
730 
731     /**
732      * Returns a count of the current number of repetitions of Ordered By Code (FT1-21).
733      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
734      * it will return zero.
735      */
736     public int getOrderedByCodeReps() {
737     	return this.getReps(21);
738     }
739 
740 
741     /**
742      * Returns a specific repetition of
743      * FT1-21: "Ordered By Code" - creates it if necessary
744      *
745      * @param rep The repetition index (0-indexed)
746      */
747     public XCN getOrderedByCode(int rep) { 
748 		XCN retVal = this.getTypedField(21, rep);
749 		return retVal;
750     }
751 
752     /**
753      * Returns a specific repetition of
754      * FT1-21: "Ordered By Code" - creates it if necessary
755      *
756      * @param rep The repetition index (0-indexed)
757      */
758     public XCN getFt121_OrderedByCode(int rep) { 
759 		XCN retVal = this.getTypedField(21, rep);
760 		return retVal;
761     }
762 
763     /**
764      * Returns a count of the current number of repetitions of Ordered By Code (FT1-21).
765      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
766      * it will return zero.
767      */
768     public int getFt121_OrderedByCodeReps() {
769     	return this.getReps(21);
770     }
771 
772 
773     /**
774      * Inserts a repetition of
775      * FT1-21: "Ordered By Code" at a specific index
776      *
777      * @param rep The repetition index (0-indexed)
778      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
779      */
780     public XCN insertOrderedByCode(int rep) throws HL7Exception { 
781         return (XCN) super.insertRepetition(21, rep);
782     }
783 
784 
785     /**
786      * Inserts a repetition of
787      * FT1-21: "Ordered By Code" at a specific index
788      *
789      * @param rep The repetition index (0-indexed)
790      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
791      */
792     public XCN insertFt121_OrderedByCode(int rep) throws HL7Exception { 
793         return (XCN) super.insertRepetition(21, rep);
794     }
795 
796 
797     /**
798      * Removes a repetition of
799      * FT1-21: "Ordered By Code" at a specific index
800      *
801      * @param rep The repetition index (0-indexed)
802      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
803      */
804     public XCN removeOrderedByCode(int rep) throws HL7Exception { 
805         return (XCN) super.removeRepetition(21, rep);
806     }
807 
808 
809     /**
810      * Removes a repetition of
811      * FT1-21: "Ordered By Code" at a specific index
812      *
813      * @param rep The repetition index (0-indexed)
814      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
815      */
816     public XCN removeFt121_OrderedByCode(int rep) throws HL7Exception { 
817         return (XCN) super.removeRepetition(21, rep);
818     }
819 
820 
821 
822 
823     /**
824      * Returns
825      * FT1-22: "Unit Cost" - creates it if necessary
826      */
827     public CP getUnitCost() { 
828 		CP retVal = this.getTypedField(22, 0);
829 		return retVal;
830     }
831     
832     /**
833      * Returns
834      * FT1-22: "Unit Cost" - creates it if necessary
835      */
836     public CP getFt122_UnitCost() { 
837 		CP retVal = this.getTypedField(22, 0);
838 		return retVal;
839     }
840 
841 
842 
843     /**
844      * Returns
845      * FT1-23: "Filler Order Number" - creates it if necessary
846      */
847     public EI getFillerOrderNumber() { 
848 		EI retVal = this.getTypedField(23, 0);
849 		return retVal;
850     }
851     
852     /**
853      * Returns
854      * FT1-23: "Filler Order Number" - creates it if necessary
855      */
856     public EI getFt123_FillerOrderNumber() { 
857 		EI retVal = this.getTypedField(23, 0);
858 		return retVal;
859     }
860 
861 
862     /**
863      * Returns all repetitions of Entered By Code (FT1-24).
864      */
865     public XCN[] getEnteredByCode() {
866     	XCN[] retVal = this.getTypedField(24, new XCN[0]);
867     	return retVal;
868     }
869 
870 
871     /**
872      * Returns all repetitions of Entered By Code (FT1-24).
873      */
874     public XCN[] getFt124_EnteredByCode() {
875     	XCN[] retVal = this.getTypedField(24, new XCN[0]);
876     	return retVal;
877     }
878 
879 
880     /**
881      * Returns a count of the current number of repetitions of Entered By Code (FT1-24).
882      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
883      * it will return zero.
884      */
885     public int getEnteredByCodeReps() {
886     	return this.getReps(24);
887     }
888 
889 
890     /**
891      * Returns a specific repetition of
892      * FT1-24: "Entered By Code" - creates it if necessary
893      *
894      * @param rep The repetition index (0-indexed)
895      */
896     public XCN getEnteredByCode(int rep) { 
897 		XCN retVal = this.getTypedField(24, rep);
898 		return retVal;
899     }
900 
901     /**
902      * Returns a specific repetition of
903      * FT1-24: "Entered By Code" - creates it if necessary
904      *
905      * @param rep The repetition index (0-indexed)
906      */
907     public XCN getFt124_EnteredByCode(int rep) { 
908 		XCN retVal = this.getTypedField(24, rep);
909 		return retVal;
910     }
911 
912     /**
913      * Returns a count of the current number of repetitions of Entered By Code (FT1-24).
914      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
915      * it will return zero.
916      */
917     public int getFt124_EnteredByCodeReps() {
918     	return this.getReps(24);
919     }
920 
921 
922     /**
923      * Inserts a repetition of
924      * FT1-24: "Entered By Code" at a specific index
925      *
926      * @param rep The repetition index (0-indexed)
927      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
928      */
929     public XCN insertEnteredByCode(int rep) throws HL7Exception { 
930         return (XCN) super.insertRepetition(24, rep);
931     }
932 
933 
934     /**
935      * Inserts a repetition of
936      * FT1-24: "Entered By Code" at a specific index
937      *
938      * @param rep The repetition index (0-indexed)
939      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
940      */
941     public XCN insertFt124_EnteredByCode(int rep) throws HL7Exception { 
942         return (XCN) super.insertRepetition(24, rep);
943     }
944 
945 
946     /**
947      * Removes a repetition of
948      * FT1-24: "Entered By Code" at a specific index
949      *
950      * @param rep The repetition index (0-indexed)
951      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
952      */
953     public XCN removeEnteredByCode(int rep) throws HL7Exception { 
954         return (XCN) super.removeRepetition(24, rep);
955     }
956 
957 
958     /**
959      * Removes a repetition of
960      * FT1-24: "Entered By Code" at a specific index
961      *
962      * @param rep The repetition index (0-indexed)
963      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
964      */
965     public XCN removeFt124_EnteredByCode(int rep) throws HL7Exception { 
966         return (XCN) super.removeRepetition(24, rep);
967     }
968 
969 
970 
971 
972     /**
973      * Returns
974      * FT1-25: "Procedure Code" - creates it if necessary
975      */
976     public CE getProcedureCode() { 
977 		CE retVal = this.getTypedField(25, 0);
978 		return retVal;
979     }
980     
981     /**
982      * Returns
983      * FT1-25: "Procedure Code" - creates it if necessary
984      */
985     public CE getFt125_ProcedureCode() { 
986 		CE retVal = this.getTypedField(25, 0);
987 		return retVal;
988     }
989 
990 
991     /**
992      * Returns all repetitions of Procedure Code Modifier (FT1-26).
993      */
994     public CE[] getProcedureCodeModifier() {
995     	CE[] retVal = this.getTypedField(26, new CE[0]);
996     	return retVal;
997     }
998 
999 
1000     /**
1001      * Returns all repetitions of Procedure Code Modifier (FT1-26).
1002      */
1003     public CE[] getFt126_ProcedureCodeModifier() {
1004     	CE[] retVal = this.getTypedField(26, new CE[0]);
1005     	return retVal;
1006     }
1007 
1008 
1009     /**
1010      * Returns a count of the current number of repetitions of Procedure Code Modifier (FT1-26).
1011      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1012      * it will return zero.
1013      */
1014     public int getProcedureCodeModifierReps() {
1015     	return this.getReps(26);
1016     }
1017 
1018 
1019     /**
1020      * Returns a specific repetition of
1021      * FT1-26: "Procedure Code Modifier" - creates it if necessary
1022      *
1023      * @param rep The repetition index (0-indexed)
1024      */
1025     public CE getProcedureCodeModifier(int rep) { 
1026 		CE retVal = this.getTypedField(26, rep);
1027 		return retVal;
1028     }
1029 
1030     /**
1031      * Returns a specific repetition of
1032      * FT1-26: "Procedure Code Modifier" - creates it if necessary
1033      *
1034      * @param rep The repetition index (0-indexed)
1035      */
1036     public CE getFt126_ProcedureCodeModifier(int rep) { 
1037 		CE retVal = this.getTypedField(26, rep);
1038 		return retVal;
1039     }
1040 
1041     /**
1042      * Returns a count of the current number of repetitions of Procedure Code Modifier (FT1-26).
1043      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1044      * it will return zero.
1045      */
1046     public int getFt126_ProcedureCodeModifierReps() {
1047     	return this.getReps(26);
1048     }
1049 
1050 
1051     /**
1052      * Inserts a repetition of
1053      * FT1-26: "Procedure Code Modifier" at a specific index
1054      *
1055      * @param rep The repetition index (0-indexed)
1056      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1057      */
1058     public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 
1059         return (CE) super.insertRepetition(26, rep);
1060     }
1061 
1062 
1063     /**
1064      * Inserts a repetition of
1065      * FT1-26: "Procedure Code Modifier" at a specific index
1066      *
1067      * @param rep The repetition index (0-indexed)
1068      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1069      */
1070     public CE insertFt126_ProcedureCodeModifier(int rep) throws HL7Exception { 
1071         return (CE) super.insertRepetition(26, rep);
1072     }
1073 
1074 
1075     /**
1076      * Removes a repetition of
1077      * FT1-26: "Procedure Code Modifier" at a specific index
1078      *
1079      * @param rep The repetition index (0-indexed)
1080      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1081      */
1082     public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 
1083         return (CE) super.removeRepetition(26, rep);
1084     }
1085 
1086 
1087     /**
1088      * Removes a repetition of
1089      * FT1-26: "Procedure Code Modifier" at a specific index
1090      *
1091      * @param rep The repetition index (0-indexed)
1092      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1093      */
1094     public CE removeFt126_ProcedureCodeModifier(int rep) throws HL7Exception { 
1095         return (CE) super.removeRepetition(26, rep);
1096     }
1097 
1098 
1099 
1100 
1101     /**
1102      * Returns
1103      * FT1-27: "Advanced Beneficiary Notice Code" - creates it if necessary
1104      */
1105     public CE getAdvancedBeneficiaryNoticeCode() { 
1106 		CE retVal = this.getTypedField(27, 0);
1107 		return retVal;
1108     }
1109     
1110     /**
1111      * Returns
1112      * FT1-27: "Advanced Beneficiary Notice Code" - creates it if necessary
1113      */
1114     public CE getFt127_AdvancedBeneficiaryNoticeCode() { 
1115 		CE retVal = this.getTypedField(27, 0);
1116 		return retVal;
1117     }
1118 
1119 
1120 
1121     /**
1122      * Returns
1123      * FT1-28: "Medically Necessary Duplicate Procedure Reason." - creates it if necessary
1124      */
1125     public CWE getMedicallyNecessaryDuplicateProcedureReason() { 
1126 		CWE retVal = this.getTypedField(28, 0);
1127 		return retVal;
1128     }
1129     
1130     /**
1131      * Returns
1132      * FT1-28: "Medically Necessary Duplicate Procedure Reason." - creates it if necessary
1133      */
1134     public CWE getFt128_MedicallyNecessaryDuplicateProcedureReason() { 
1135 		CWE retVal = this.getTypedField(28, 0);
1136 		return retVal;
1137     }
1138 
1139 
1140 
1141     /**
1142      * Returns
1143      * FT1-29: "NDC Code" - creates it if necessary
1144      */
1145     public CNE getNDCCode() { 
1146 		CNE retVal = this.getTypedField(29, 0);
1147 		return retVal;
1148     }
1149     
1150     /**
1151      * Returns
1152      * FT1-29: "NDC Code" - creates it if necessary
1153      */
1154     public CNE getFt129_NDCCode() { 
1155 		CNE retVal = this.getTypedField(29, 0);
1156 		return retVal;
1157     }
1158 
1159 
1160 
1161     /**
1162      * Returns
1163      * FT1-30: "Payment Reference ID" - creates it if necessary
1164      */
1165     public CX getPaymentReferenceID() { 
1166 		CX retVal = this.getTypedField(30, 0);
1167 		return retVal;
1168     }
1169     
1170     /**
1171      * Returns
1172      * FT1-30: "Payment Reference ID" - creates it if necessary
1173      */
1174     public CX getFt130_PaymentReferenceID() { 
1175 		CX retVal = this.getTypedField(30, 0);
1176 		return retVal;
1177     }
1178 
1179 
1180     /**
1181      * Returns all repetitions of Transaction Reference Key (FT1-31).
1182      */
1183     public SI[] getTransactionReferenceKey() {
1184     	SI[] retVal = this.getTypedField(31, new SI[0]);
1185     	return retVal;
1186     }
1187 
1188 
1189     /**
1190      * Returns all repetitions of Transaction Reference Key (FT1-31).
1191      */
1192     public SI[] getFt131_TransactionReferenceKey() {
1193     	SI[] retVal = this.getTypedField(31, new SI[0]);
1194     	return retVal;
1195     }
1196 
1197 
1198     /**
1199      * Returns a count of the current number of repetitions of Transaction Reference Key (FT1-31).
1200      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1201      * it will return zero.
1202      */
1203     public int getTransactionReferenceKeyReps() {
1204     	return this.getReps(31);
1205     }
1206 
1207 
1208     /**
1209      * Returns a specific repetition of
1210      * FT1-31: "Transaction Reference Key" - creates it if necessary
1211      *
1212      * @param rep The repetition index (0-indexed)
1213      */
1214     public SI getTransactionReferenceKey(int rep) { 
1215 		SI retVal = this.getTypedField(31, rep);
1216 		return retVal;
1217     }
1218 
1219     /**
1220      * Returns a specific repetition of
1221      * FT1-31: "Transaction Reference Key" - creates it if necessary
1222      *
1223      * @param rep The repetition index (0-indexed)
1224      */
1225     public SI getFt131_TransactionReferenceKey(int rep) { 
1226 		SI retVal = this.getTypedField(31, rep);
1227 		return retVal;
1228     }
1229 
1230     /**
1231      * Returns a count of the current number of repetitions of Transaction Reference Key (FT1-31).
1232      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1233      * it will return zero.
1234      */
1235     public int getFt131_TransactionReferenceKeyReps() {
1236     	return this.getReps(31);
1237     }
1238 
1239 
1240     /**
1241      * Inserts a repetition of
1242      * FT1-31: "Transaction Reference Key" at a specific index
1243      *
1244      * @param rep The repetition index (0-indexed)
1245      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1246      */
1247     public SI insertTransactionReferenceKey(int rep) throws HL7Exception { 
1248         return (SI) super.insertRepetition(31, rep);
1249     }
1250 
1251 
1252     /**
1253      * Inserts a repetition of
1254      * FT1-31: "Transaction Reference Key" at a specific index
1255      *
1256      * @param rep The repetition index (0-indexed)
1257      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1258      */
1259     public SI insertFt131_TransactionReferenceKey(int rep) throws HL7Exception { 
1260         return (SI) super.insertRepetition(31, rep);
1261     }
1262 
1263 
1264     /**
1265      * Removes a repetition of
1266      * FT1-31: "Transaction Reference Key" at a specific index
1267      *
1268      * @param rep The repetition index (0-indexed)
1269      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1270      */
1271     public SI removeTransactionReferenceKey(int rep) throws HL7Exception { 
1272         return (SI) super.removeRepetition(31, rep);
1273     }
1274 
1275 
1276     /**
1277      * Removes a repetition of
1278      * FT1-31: "Transaction Reference Key" 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 SI removeFt131_TransactionReferenceKey(int rep) throws HL7Exception { 
1284         return (SI) super.removeRepetition(31, rep);
1285     }
1286 
1287 
1288 
1289 
1290 
1291 
1292     /** {@inheritDoc} */   
1293     protected Type createNewTypeWithoutReflection(int field) {
1294        switch (field) {
1295           case 0: return new SI(getMessage());
1296           case 1: return new ST(getMessage());
1297           case 2: return new ST(getMessage());
1298           case 3: return new DR(getMessage());
1299           case 4: return new TS(getMessage());
1300           case 5: return new IS(getMessage(), new Integer( 17 ));
1301           case 6: return new CE(getMessage());
1302           case 7: return new ST(getMessage());
1303           case 8: return new ST(getMessage());
1304           case 9: return new NM(getMessage());
1305           case 10: return new CP(getMessage());
1306           case 11: return new CP(getMessage());
1307           case 12: return new CE(getMessage());
1308           case 13: return new CE(getMessage());
1309           case 14: return new CP(getMessage());
1310           case 15: return new PL(getMessage());
1311           case 16: return new IS(getMessage(), new Integer( 24 ));
1312           case 17: return new IS(getMessage(), new Integer( 18 ));
1313           case 18: return new CE(getMessage());
1314           case 19: return new XCN(getMessage());
1315           case 20: return new XCN(getMessage());
1316           case 21: return new CP(getMessage());
1317           case 22: return new EI(getMessage());
1318           case 23: return new XCN(getMessage());
1319           case 24: return new CE(getMessage());
1320           case 25: return new CE(getMessage());
1321           case 26: return new CE(getMessage());
1322           case 27: return new CWE(getMessage());
1323           case 28: return new CNE(getMessage());
1324           case 29: return new CX(getMessage());
1325           case 30: return new SI(getMessage());
1326           default: return null;
1327        }
1328    }
1329 
1330 
1331 }
1332