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