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.v25.segment; 035 036// import ca.uhn.hl7v2.model.v25.group.*; 037import ca.uhn.hl7v2.model.v25.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