Source code

001/*
002 * This class is an auto-generated source file for a HAPI
003 * HL7 v2.x standard structure class.
004 *
005 * For more information, visit: http://hl7api.sourceforge.net/
006 * 
007 * The contents of this file are subject to the Mozilla Public License Version 1.1 
008 * (the "License"); you may not use this file except in compliance with the License. 
009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
010 * Software distributed under the License is distributed on an "AS IS" basis, 
011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
012 * specific language governing rights and limitations under the License. 
013 * 
014 * The Original Code is "[file_name]".  Description: 
015 * "[one_line_description]" 
016 * 
017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
018 * 2012.  All Rights Reserved. 
019 * 
020 * Contributor(s): ______________________________________. 
021 * 
022 * Alternatively, the contents of this file may be used under the terms of the 
023 * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
024 * applicable instead of those above.  If you wish to allow use of your version of this 
025 * file only under the terms of the GPL and not to allow others to use your version 
026 * of this file under the MPL, indicate your decision by deleting  the provisions above 
027 * and replace  them with the notice and other provisions required by the GPL License.  
028 * If you do not delete the provisions above, a recipient may use your version of 
029 * this file under either the MPL or the GPL. 
030 * 
031 */
032
033
034package ca.uhn.hl7v2.model.v251.segment;
035
036// import ca.uhn.hl7v2.model.v251.group.*;
037import ca.uhn.hl7v2.model.v251.datatype.*;
038import ca.uhn.hl7v2.HL7Exception;
039import ca.uhn.hl7v2.parser.ModelClassFactory;
040import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
041import ca.uhn.hl7v2.model.AbstractMessage;
042import ca.uhn.hl7v2.model.Group;
043import ca.uhn.hl7v2.model.Type;
044import ca.uhn.hl7v2.model.AbstractSegment;
045import ca.uhn.hl7v2.model.Varies;
046
047
048/**
049 *<p>Represents an HL7 FT1 message segment (Financial Transaction). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>FT1-1: Set ID - FT1 (SI) <b>optional </b>
053     * <li>FT1-2: Transaction ID (ST) <b>optional </b>
054     * <li>FT1-3: Transaction Batch ID (ST) <b>optional </b>
055     * <li>FT1-4: Transaction Date (DR) <b> </b>
056     * <li>FT1-5: Transaction Posting Date (TS) <b>optional </b>
057     * <li>FT1-6: Transaction Type (IS) <b> </b>
058     * <li>FT1-7: Transaction Code (CE) <b> </b>
059     * <li>FT1-8: Transaction Description (ST) <b>optional </b>
060     * <li>FT1-9: Transaction Description - Alt (ST) <b>optional </b>
061     * <li>FT1-10: Transaction Quantity (NM) <b>optional </b>
062     * <li>FT1-11: Transaction Amount - Extended (CP) <b>optional </b>
063     * <li>FT1-12: Transaction Amount - Unit (CP) <b>optional </b>
064     * <li>FT1-13: Department Code (CE) <b>optional </b>
065     * <li>FT1-14: Insurance Plan ID (CE) <b>optional </b>
066     * <li>FT1-15: Insurance Amount (CP) <b>optional </b>
067     * <li>FT1-16: Assigned Patient Location (PL) <b>optional </b>
068     * <li>FT1-17: Fee Schedule (IS) <b>optional </b>
069     * <li>FT1-18: Patient Type (IS) <b>optional </b>
070     * <li>FT1-19: Diagnosis Code - FT1 (CE) <b>optional repeating</b>
071     * <li>FT1-20: Performed By Code (XCN) <b>optional repeating</b>
072     * <li>FT1-21: Ordered By Code (XCN) <b>optional repeating</b>
073     * <li>FT1-22: Unit Cost (CP) <b>optional </b>
074     * <li>FT1-23: Filler Order Number (EI) <b>optional </b>
075     * <li>FT1-24: Entered By Code (XCN) <b>optional repeating</b>
076     * <li>FT1-25: Procedure Code (CE) <b>optional </b>
077     * <li>FT1-26: Procedure Code Modifier (CE) <b>optional repeating</b>
078     * <li>FT1-27: Advanced Beneficiary Notice Code (CE) <b>optional </b>
079     * <li>FT1-28: Medically Necessary Duplicate Procedure Reason. (CWE) <b>optional </b>
080     * <li>FT1-29: NDC Code (CNE) <b>optional </b>
081     * <li>FT1-30: Payment Reference ID (CX) <b>optional </b>
082     * <li>FT1-31: Transaction Reference Key (SI) <b>optional repeating</b>
083 * </ul>
084 */
085@SuppressWarnings("unused")
086public class FT1 extends AbstractSegment {
087
088    /** 
089     * Creates a new FT1 segment
090     */
091    public FT1(Group parent, ModelClassFactory factory) {
092       super(parent, factory);
093       init(factory);
094    }
095
096    private void init(ModelClassFactory factory) {
097       try {
098                                  this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - FT1");
099                                  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