001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v251.segment; 035 036// import ca.uhn.hl7v2.model.v251.group.*; 037import ca.uhn.hl7v2.model.v251.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 IN1 message segment (Insurance). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>IN1-1: Set ID - IN1 (SI) <b> </b> 053 * <li>IN1-2: Insurance Plan ID (CE) <b> </b> 054 * <li>IN1-3: Insurance Company ID (CX) <b> repeating</b> 055 * <li>IN1-4: Insurance Company Name (XON) <b>optional repeating</b> 056 * <li>IN1-5: Insurance Company Address (XAD) <b>optional repeating</b> 057 * <li>IN1-6: Insurance Co Contact Person (XPN) <b>optional repeating</b> 058 * <li>IN1-7: Insurance Co Phone Number (XTN) <b>optional repeating</b> 059 * <li>IN1-8: Group Number (ST) <b>optional </b> 060 * <li>IN1-9: Group Name (XON) <b>optional repeating</b> 061 * <li>IN1-10: Insured's Group Emp ID (CX) <b>optional repeating</b> 062 * <li>IN1-11: Insured's Group Emp Name (XON) <b>optional repeating</b> 063 * <li>IN1-12: Plan Effective Date (DT) <b>optional </b> 064 * <li>IN1-13: Plan Expiration Date (DT) <b>optional </b> 065 * <li>IN1-14: Authorization Information (AUI) <b>optional </b> 066 * <li>IN1-15: Plan Type (IS) <b>optional </b> 067 * <li>IN1-16: Name Of Insured (XPN) <b>optional repeating</b> 068 * <li>IN1-17: Insured's Relationship To Patient (CE) <b>optional </b> 069 * <li>IN1-18: Insured's Date Of Birth (TS) <b>optional </b> 070 * <li>IN1-19: Insured's Address (XAD) <b>optional repeating</b> 071 * <li>IN1-20: Assignment Of Benefits (IS) <b>optional </b> 072 * <li>IN1-21: Coordination Of Benefits (IS) <b>optional </b> 073 * <li>IN1-22: Coord Of Ben. Priority (ST) <b>optional </b> 074 * <li>IN1-23: Notice Of Admission Flag (ID) <b>optional </b> 075 * <li>IN1-24: Notice Of Admission Date (DT) <b>optional </b> 076 * <li>IN1-25: Report Of Eligibility Flag (ID) <b>optional </b> 077 * <li>IN1-26: Report Of Eligibility Date (DT) <b>optional </b> 078 * <li>IN1-27: Release Information Code (IS) <b>optional </b> 079 * <li>IN1-28: Pre-Admit Cert (PAC) (ST) <b>optional </b> 080 * <li>IN1-29: Verification Date/Time (TS) <b>optional </b> 081 * <li>IN1-30: Verification By (XCN) <b>optional repeating</b> 082 * <li>IN1-31: Type Of Agreement Code (IS) <b>optional </b> 083 * <li>IN1-32: Billing Status (IS) <b>optional </b> 084 * <li>IN1-33: Lifetime Reserve Days (NM) <b>optional </b> 085 * <li>IN1-34: Delay Before L.R. Day (NM) <b>optional </b> 086 * <li>IN1-35: Company Plan Code (IS) <b>optional </b> 087 * <li>IN1-36: Policy Number (ST) <b>optional </b> 088 * <li>IN1-37: Policy Deductible (CP) <b>optional </b> 089 * <li>IN1-38: Policy Limit - Amount (CP) <b>optional </b> 090 * <li>IN1-39: Policy Limit - Days (NM) <b>optional </b> 091 * <li>IN1-40: Room Rate - Semi-Private (CP) <b>optional </b> 092 * <li>IN1-41: Room Rate - Private (CP) <b>optional </b> 093 * <li>IN1-42: Insured's Employment Status (CE) <b>optional </b> 094 * <li>IN1-43: Insured's Administrative Sex (IS) <b>optional </b> 095 * <li>IN1-44: Insured's Employer's Address (XAD) <b>optional repeating</b> 096 * <li>IN1-45: Verification Status (ST) <b>optional </b> 097 * <li>IN1-46: Prior Insurance Plan ID (IS) <b>optional </b> 098 * <li>IN1-47: Coverage Type (IS) <b>optional </b> 099 * <li>IN1-48: Handicap (IS) <b>optional </b> 100 * <li>IN1-49: Insured's ID Number (CX) <b>optional repeating</b> 101 * <li>IN1-50: Signature Code (IS) <b>optional </b> 102 * <li>IN1-51: Signature Code Date (DT) <b>optional </b> 103 * <li>IN1-52: Insured's Birth Place (ST) <b>optional </b> 104 * <li>IN1-53: VIP Indicator (IS) <b>optional </b> 105 * </ul> 106 */ 107@SuppressWarnings("unused") 108public class IN1 extends AbstractSegment { 109 110 /** 111 * Creates a new IN1 segment 112 */ 113 public IN1(Group parent, ModelClassFactory factory) { 114 super(parent, factory); 115 init(factory); 116 } 117 118 private void init(ModelClassFactory factory) { 119 try { 120 this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - IN1"); 121 this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Insurance Plan ID"); 122 this.add(CX.class, true, 0, 250, new Object[]{ getMessage() }, "Insurance Company ID"); 123 this.add(XON.class, false, 0, 250, new Object[]{ getMessage() }, "Insurance Company Name"); 124 this.add(XAD.class, false, 0, 250, new Object[]{ getMessage() }, "Insurance Company Address"); 125 this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Insurance Co Contact Person"); 126 this.add(XTN.class, false, 0, 250, new Object[]{ getMessage() }, "Insurance Co Phone Number"); 127 this.add(ST.class, false, 1, 12, new Object[]{ getMessage() }, "Group Number"); 128 this.add(XON.class, false, 0, 250, new Object[]{ getMessage() }, "Group Name"); 129 this.add(CX.class, false, 0, 250, new Object[]{ getMessage() }, "Insured's Group Emp ID"); 130 this.add(XON.class, false, 0, 250, new Object[]{ getMessage() }, "Insured's Group Emp Name"); 131 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Plan Effective Date"); 132 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Plan Expiration Date"); 133 this.add(AUI.class, false, 1, 239, new Object[]{ getMessage() }, "Authorization Information"); 134 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(86) }, "Plan Type"); 135 this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Name Of Insured"); 136 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Insured's Relationship To Patient"); 137 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Insured's Date Of Birth"); 138 this.add(XAD.class, false, 0, 250, new Object[]{ getMessage() }, "Insured's Address"); 139 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(135) }, "Assignment Of Benefits"); 140 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(173) }, "Coordination Of Benefits"); 141 this.add(ST.class, false, 1, 2, new Object[]{ getMessage() }, "Coord Of Ben. Priority"); 142 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Notice Of Admission Flag"); 143 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Notice Of Admission Date"); 144 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Report Of Eligibility Flag"); 145 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Report Of Eligibility Date"); 146 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(93) }, "Release Information Code"); 147 this.add(ST.class, false, 1, 15, new Object[]{ getMessage() }, "Pre-Admit Cert (PAC)"); 148 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Verification Date/Time"); 149 this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Verification By"); 150 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(98) }, "Type Of Agreement Code"); 151 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(22) }, "Billing Status"); 152 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Lifetime Reserve Days"); 153 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Delay Before L.R. Day"); 154 this.add(IS.class, false, 1, 8, new Object[]{ getMessage(), new Integer(42) }, "Company Plan Code"); 155 this.add(ST.class, false, 1, 15, new Object[]{ getMessage() }, "Policy Number"); 156 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Policy Deductible"); 157 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Policy Limit - Amount"); 158 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Policy Limit - Days"); 159 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Room Rate - Semi-Private"); 160 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Room Rate - Private"); 161 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Insured's Employment Status"); 162 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Insured's Administrative Sex"); 163 this.add(XAD.class, false, 0, 250, new Object[]{ getMessage() }, "Insured's Employer's Address"); 164 this.add(ST.class, false, 1, 2, new Object[]{ getMessage() }, "Verification Status"); 165 this.add(IS.class, false, 1, 8, new Object[]{ getMessage(), new Integer(72) }, "Prior Insurance Plan ID"); 166 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(309) }, "Coverage Type"); 167 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(295) }, "Handicap"); 168 this.add(CX.class, false, 0, 250, new Object[]{ getMessage() }, "Insured's ID Number"); 169 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(535) }, "Signature Code"); 170 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Signature Code Date"); 171 this.add(ST.class, false, 1, 250, new Object[]{ getMessage() }, "Insured's Birth Place"); 172 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(99) }, "VIP Indicator"); 173 } catch(HL7Exception e) { 174 log.error("Unexpected error creating IN1 - this is probably a bug in the source code generator.", e); 175 } 176 } 177 178 179 180 /** 181 * Returns 182 * IN1-1: "Set ID - IN1" - creates it if necessary 183 */ 184 public SI getSetIDIN1() { 185 SI retVal = this.getTypedField(1, 0); 186 return retVal; 187 } 188 189 /** 190 * Returns 191 * IN1-1: "Set ID - IN1" - creates it if necessary 192 */ 193 public SI getIn11_SetIDIN1() { 194 SI retVal = this.getTypedField(1, 0); 195 return retVal; 196 } 197 198 199 200 /** 201 * Returns 202 * IN1-2: "Insurance Plan ID" - creates it if necessary 203 */ 204 public CE getInsurancePlanID() { 205 CE retVal = this.getTypedField(2, 0); 206 return retVal; 207 } 208 209 /** 210 * Returns 211 * IN1-2: "Insurance Plan ID" - creates it if necessary 212 */ 213 public CE getIn12_InsurancePlanID() { 214 CE retVal = this.getTypedField(2, 0); 215 return retVal; 216 } 217 218 219 /** 220 * Returns all repetitions of Insurance Company ID (IN1-3). 221 */ 222 public CX[] getInsuranceCompanyID() { 223 CX[] retVal = this.getTypedField(3, new CX[0]); 224 return retVal; 225 } 226 227 228 /** 229 * Returns all repetitions of Insurance Company ID (IN1-3). 230 */ 231 public CX[] getIn13_InsuranceCompanyID() { 232 CX[] retVal = this.getTypedField(3, new CX[0]); 233 return retVal; 234 } 235 236 237 /** 238 * Returns a count of the current number of repetitions of Insurance Company ID (IN1-3). 239 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 240 * it will return zero. 241 */ 242 public int getInsuranceCompanyIDReps() { 243 return this.getReps(3); 244 } 245 246 247 /** 248 * Returns a specific repetition of 249 * IN1-3: "Insurance Company ID" - creates it if necessary 250 * 251 * @param rep The repetition index (0-indexed) 252 */ 253 public CX getInsuranceCompanyID(int rep) { 254 CX retVal = this.getTypedField(3, rep); 255 return retVal; 256 } 257 258 /** 259 * Returns a specific repetition of 260 * IN1-3: "Insurance Company ID" - creates it if necessary 261 * 262 * @param rep The repetition index (0-indexed) 263 */ 264 public CX getIn13_InsuranceCompanyID(int rep) { 265 CX retVal = this.getTypedField(3, rep); 266 return retVal; 267 } 268 269 /** 270 * Returns a count of the current number of repetitions of Insurance Company ID (IN1-3). 271 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 272 * it will return zero. 273 */ 274 public int getIn13_InsuranceCompanyIDReps() { 275 return this.getReps(3); 276 } 277 278 279 /** 280 * Inserts a repetition of 281 * IN1-3: "Insurance Company ID" at a specific index 282 * 283 * @param rep The repetition index (0-indexed) 284 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 285 */ 286 public CX insertInsuranceCompanyID(int rep) throws HL7Exception { 287 return (CX) super.insertRepetition(3, rep); 288 } 289 290 291 /** 292 * Inserts a repetition of 293 * IN1-3: "Insurance Company ID" at a specific index 294 * 295 * @param rep The repetition index (0-indexed) 296 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 297 */ 298 public CX insertIn13_InsuranceCompanyID(int rep) throws HL7Exception { 299 return (CX) super.insertRepetition(3, rep); 300 } 301 302 303 /** 304 * Removes a repetition of 305 * IN1-3: "Insurance Company ID" at a specific index 306 * 307 * @param rep The repetition index (0-indexed) 308 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 309 */ 310 public CX removeInsuranceCompanyID(int rep) throws HL7Exception { 311 return (CX) super.removeRepetition(3, rep); 312 } 313 314 315 /** 316 * Removes a repetition of 317 * IN1-3: "Insurance Company ID" at a specific index 318 * 319 * @param rep The repetition index (0-indexed) 320 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 321 */ 322 public CX removeIn13_InsuranceCompanyID(int rep) throws HL7Exception { 323 return (CX) super.removeRepetition(3, rep); 324 } 325 326 327 328 /** 329 * Returns all repetitions of Insurance Company Name (IN1-4). 330 */ 331 public XON[] getInsuranceCompanyName() { 332 XON[] retVal = this.getTypedField(4, new XON[0]); 333 return retVal; 334 } 335 336 337 /** 338 * Returns all repetitions of Insurance Company Name (IN1-4). 339 */ 340 public XON[] getIn14_InsuranceCompanyName() { 341 XON[] retVal = this.getTypedField(4, new XON[0]); 342 return retVal; 343 } 344 345 346 /** 347 * Returns a count of the current number of repetitions of Insurance Company Name (IN1-4). 348 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 349 * it will return zero. 350 */ 351 public int getInsuranceCompanyNameReps() { 352 return this.getReps(4); 353 } 354 355 356 /** 357 * Returns a specific repetition of 358 * IN1-4: "Insurance Company Name" - creates it if necessary 359 * 360 * @param rep The repetition index (0-indexed) 361 */ 362 public XON getInsuranceCompanyName(int rep) { 363 XON retVal = this.getTypedField(4, rep); 364 return retVal; 365 } 366 367 /** 368 * Returns a specific repetition of 369 * IN1-4: "Insurance Company Name" - creates it if necessary 370 * 371 * @param rep The repetition index (0-indexed) 372 */ 373 public XON getIn14_InsuranceCompanyName(int rep) { 374 XON retVal = this.getTypedField(4, rep); 375 return retVal; 376 } 377 378 /** 379 * Returns a count of the current number of repetitions of Insurance Company Name (IN1-4). 380 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 381 * it will return zero. 382 */ 383 public int getIn14_InsuranceCompanyNameReps() { 384 return this.getReps(4); 385 } 386 387 388 /** 389 * Inserts a repetition of 390 * IN1-4: "Insurance Company Name" at a specific index 391 * 392 * @param rep The repetition index (0-indexed) 393 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 394 */ 395 public XON insertInsuranceCompanyName(int rep) throws HL7Exception { 396 return (XON) super.insertRepetition(4, rep); 397 } 398 399 400 /** 401 * Inserts a repetition of 402 * IN1-4: "Insurance Company Name" at a specific index 403 * 404 * @param rep The repetition index (0-indexed) 405 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 406 */ 407 public XON insertIn14_InsuranceCompanyName(int rep) throws HL7Exception { 408 return (XON) super.insertRepetition(4, rep); 409 } 410 411 412 /** 413 * Removes a repetition of 414 * IN1-4: "Insurance Company Name" at a specific index 415 * 416 * @param rep The repetition index (0-indexed) 417 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 418 */ 419 public XON removeInsuranceCompanyName(int rep) throws HL7Exception { 420 return (XON) super.removeRepetition(4, rep); 421 } 422 423 424 /** 425 * Removes a repetition of 426 * IN1-4: "Insurance Company Name" at a specific index 427 * 428 * @param rep The repetition index (0-indexed) 429 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 430 */ 431 public XON removeIn14_InsuranceCompanyName(int rep) throws HL7Exception { 432 return (XON) super.removeRepetition(4, rep); 433 } 434 435 436 437 /** 438 * Returns all repetitions of Insurance Company Address (IN1-5). 439 */ 440 public XAD[] getInsuranceCompanyAddress() { 441 XAD[] retVal = this.getTypedField(5, new XAD[0]); 442 return retVal; 443 } 444 445 446 /** 447 * Returns all repetitions of Insurance Company Address (IN1-5). 448 */ 449 public XAD[] getIn15_InsuranceCompanyAddress() { 450 XAD[] retVal = this.getTypedField(5, new XAD[0]); 451 return retVal; 452 } 453 454 455 /** 456 * Returns a count of the current number of repetitions of Insurance Company Address (IN1-5). 457 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 458 * it will return zero. 459 */ 460 public int getInsuranceCompanyAddressReps() { 461 return this.getReps(5); 462 } 463 464 465 /** 466 * Returns a specific repetition of 467 * IN1-5: "Insurance Company Address" - creates it if necessary 468 * 469 * @param rep The repetition index (0-indexed) 470 */ 471 public XAD getInsuranceCompanyAddress(int rep) { 472 XAD retVal = this.getTypedField(5, rep); 473 return retVal; 474 } 475 476 /** 477 * Returns a specific repetition of 478 * IN1-5: "Insurance Company Address" - creates it if necessary 479 * 480 * @param rep The repetition index (0-indexed) 481 */ 482 public XAD getIn15_InsuranceCompanyAddress(int rep) { 483 XAD retVal = this.getTypedField(5, rep); 484 return retVal; 485 } 486 487 /** 488 * Returns a count of the current number of repetitions of Insurance Company Address (IN1-5). 489 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 490 * it will return zero. 491 */ 492 public int getIn15_InsuranceCompanyAddressReps() { 493 return this.getReps(5); 494 } 495 496 497 /** 498 * Inserts a repetition of 499 * IN1-5: "Insurance Company Address" at a specific index 500 * 501 * @param rep The repetition index (0-indexed) 502 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 503 */ 504 public XAD insertInsuranceCompanyAddress(int rep) throws HL7Exception { 505 return (XAD) super.insertRepetition(5, rep); 506 } 507 508 509 /** 510 * Inserts a repetition of 511 * IN1-5: "Insurance Company Address" at a specific index 512 * 513 * @param rep The repetition index (0-indexed) 514 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 515 */ 516 public XAD insertIn15_InsuranceCompanyAddress(int rep) throws HL7Exception { 517 return (XAD) super.insertRepetition(5, rep); 518 } 519 520 521 /** 522 * Removes a repetition of 523 * IN1-5: "Insurance Company Address" at a specific index 524 * 525 * @param rep The repetition index (0-indexed) 526 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 527 */ 528 public XAD removeInsuranceCompanyAddress(int rep) throws HL7Exception { 529 return (XAD) super.removeRepetition(5, rep); 530 } 531 532 533 /** 534 * Removes a repetition of 535 * IN1-5: "Insurance Company Address" at a specific index 536 * 537 * @param rep The repetition index (0-indexed) 538 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 539 */ 540 public XAD removeIn15_InsuranceCompanyAddress(int rep) throws HL7Exception { 541 return (XAD) super.removeRepetition(5, rep); 542 } 543 544 545 546 /** 547 * Returns all repetitions of Insurance Co Contact Person (IN1-6). 548 */ 549 public XPN[] getInsuranceCoContactPerson() { 550 XPN[] retVal = this.getTypedField(6, new XPN[0]); 551 return retVal; 552 } 553 554 555 /** 556 * Returns all repetitions of Insurance Co Contact Person (IN1-6). 557 */ 558 public XPN[] getIn16_InsuranceCoContactPerson() { 559 XPN[] retVal = this.getTypedField(6, new XPN[0]); 560 return retVal; 561 } 562 563 564 /** 565 * Returns a count of the current number of repetitions of Insurance Co Contact Person (IN1-6). 566 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 567 * it will return zero. 568 */ 569 public int getInsuranceCoContactPersonReps() { 570 return this.getReps(6); 571 } 572 573 574 /** 575 * Returns a specific repetition of 576 * IN1-6: "Insurance Co Contact Person" - creates it if necessary 577 * 578 * @param rep The repetition index (0-indexed) 579 */ 580 public XPN getInsuranceCoContactPerson(int rep) { 581 XPN retVal = this.getTypedField(6, rep); 582 return retVal; 583 } 584 585 /** 586 * Returns a specific repetition of 587 * IN1-6: "Insurance Co Contact Person" - creates it if necessary 588 * 589 * @param rep The repetition index (0-indexed) 590 */ 591 public XPN getIn16_InsuranceCoContactPerson(int rep) { 592 XPN retVal = this.getTypedField(6, rep); 593 return retVal; 594 } 595 596 /** 597 * Returns a count of the current number of repetitions of Insurance Co Contact Person (IN1-6). 598 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 599 * it will return zero. 600 */ 601 public int getIn16_InsuranceCoContactPersonReps() { 602 return this.getReps(6); 603 } 604 605 606 /** 607 * Inserts a repetition of 608 * IN1-6: "Insurance Co Contact Person" at a specific index 609 * 610 * @param rep The repetition index (0-indexed) 611 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 612 */ 613 public XPN insertInsuranceCoContactPerson(int rep) throws HL7Exception { 614 return (XPN) super.insertRepetition(6, rep); 615 } 616 617 618 /** 619 * Inserts a repetition of 620 * IN1-6: "Insurance Co Contact Person" at a specific index 621 * 622 * @param rep The repetition index (0-indexed) 623 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 624 */ 625 public XPN insertIn16_InsuranceCoContactPerson(int rep) throws HL7Exception { 626 return (XPN) super.insertRepetition(6, rep); 627 } 628 629 630 /** 631 * Removes a repetition of 632 * IN1-6: "Insurance Co Contact Person" at a specific index 633 * 634 * @param rep The repetition index (0-indexed) 635 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 636 */ 637 public XPN removeInsuranceCoContactPerson(int rep) throws HL7Exception { 638 return (XPN) super.removeRepetition(6, rep); 639 } 640 641 642 /** 643 * Removes a repetition of 644 * IN1-6: "Insurance Co Contact Person" at a specific index 645 * 646 * @param rep The repetition index (0-indexed) 647 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 648 */ 649 public XPN removeIn16_InsuranceCoContactPerson(int rep) throws HL7Exception { 650 return (XPN) super.removeRepetition(6, rep); 651 } 652 653 654 655 /** 656 * Returns all repetitions of Insurance Co Phone Number (IN1-7). 657 */ 658 public XTN[] getInsuranceCoPhoneNumber() { 659 XTN[] retVal = this.getTypedField(7, new XTN[0]); 660 return retVal; 661 } 662 663 664 /** 665 * Returns all repetitions of Insurance Co Phone Number (IN1-7). 666 */ 667 public XTN[] getIn17_InsuranceCoPhoneNumber() { 668 XTN[] retVal = this.getTypedField(7, new XTN[0]); 669 return retVal; 670 } 671 672 673 /** 674 * Returns a count of the current number of repetitions of Insurance Co Phone Number (IN1-7). 675 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 676 * it will return zero. 677 */ 678 public int getInsuranceCoPhoneNumberReps() { 679 return this.getReps(7); 680 } 681 682 683 /** 684 * Returns a specific repetition of 685 * IN1-7: "Insurance Co Phone Number" - creates it if necessary 686 * 687 * @param rep The repetition index (0-indexed) 688 */ 689 public XTN getInsuranceCoPhoneNumber(int rep) { 690 XTN retVal = this.getTypedField(7, rep); 691 return retVal; 692 } 693 694 /** 695 * Returns a specific repetition of 696 * IN1-7: "Insurance Co Phone Number" - creates it if necessary 697 * 698 * @param rep The repetition index (0-indexed) 699 */ 700 public XTN getIn17_InsuranceCoPhoneNumber(int rep) { 701 XTN retVal = this.getTypedField(7, rep); 702 return retVal; 703 } 704 705 /** 706 * Returns a count of the current number of repetitions of Insurance Co Phone Number (IN1-7). 707 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 708 * it will return zero. 709 */ 710 public int getIn17_InsuranceCoPhoneNumberReps() { 711 return this.getReps(7); 712 } 713 714 715 /** 716 * Inserts a repetition of 717 * IN1-7: "Insurance Co Phone Number" at a specific index 718 * 719 * @param rep The repetition index (0-indexed) 720 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 721 */ 722 public XTN insertInsuranceCoPhoneNumber(int rep) throws HL7Exception { 723 return (XTN) super.insertRepetition(7, rep); 724 } 725 726 727 /** 728 * Inserts a repetition of 729 * IN1-7: "Insurance Co Phone Number" at a specific index 730 * 731 * @param rep The repetition index (0-indexed) 732 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 733 */ 734 public XTN insertIn17_InsuranceCoPhoneNumber(int rep) throws HL7Exception { 735 return (XTN) super.insertRepetition(7, rep); 736 } 737 738 739 /** 740 * Removes a repetition of 741 * IN1-7: "Insurance Co Phone Number" at a specific index 742 * 743 * @param rep The repetition index (0-indexed) 744 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 745 */ 746 public XTN removeInsuranceCoPhoneNumber(int rep) throws HL7Exception { 747 return (XTN) super.removeRepetition(7, rep); 748 } 749 750 751 /** 752 * Removes a repetition of 753 * IN1-7: "Insurance Co Phone Number" at a specific index 754 * 755 * @param rep The repetition index (0-indexed) 756 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 757 */ 758 public XTN removeIn17_InsuranceCoPhoneNumber(int rep) throws HL7Exception { 759 return (XTN) super.removeRepetition(7, rep); 760 } 761 762 763 764 765 /** 766 * Returns 767 * IN1-8: "Group Number" - creates it if necessary 768 */ 769 public ST getGroupNumber() { 770 ST retVal = this.getTypedField(8, 0); 771 return retVal; 772 } 773 774 /** 775 * Returns 776 * IN1-8: "Group Number" - creates it if necessary 777 */ 778 public ST getIn18_GroupNumber() { 779 ST retVal = this.getTypedField(8, 0); 780 return retVal; 781 } 782 783 784 /** 785 * Returns all repetitions of Group Name (IN1-9). 786 */ 787 public XON[] getGroupName() { 788 XON[] retVal = this.getTypedField(9, new XON[0]); 789 return retVal; 790 } 791 792 793 /** 794 * Returns all repetitions of Group Name (IN1-9). 795 */ 796 public XON[] getIn19_GroupName() { 797 XON[] retVal = this.getTypedField(9, new XON[0]); 798 return retVal; 799 } 800 801 802 /** 803 * Returns a count of the current number of repetitions of Group Name (IN1-9). 804 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 805 * it will return zero. 806 */ 807 public int getGroupNameReps() { 808 return this.getReps(9); 809 } 810 811 812 /** 813 * Returns a specific repetition of 814 * IN1-9: "Group Name" - creates it if necessary 815 * 816 * @param rep The repetition index (0-indexed) 817 */ 818 public XON getGroupName(int rep) { 819 XON retVal = this.getTypedField(9, rep); 820 return retVal; 821 } 822 823 /** 824 * Returns a specific repetition of 825 * IN1-9: "Group Name" - creates it if necessary 826 * 827 * @param rep The repetition index (0-indexed) 828 */ 829 public XON getIn19_GroupName(int rep) { 830 XON retVal = this.getTypedField(9, rep); 831 return retVal; 832 } 833 834 /** 835 * Returns a count of the current number of repetitions of Group Name (IN1-9). 836 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 837 * it will return zero. 838 */ 839 public int getIn19_GroupNameReps() { 840 return this.getReps(9); 841 } 842 843 844 /** 845 * Inserts a repetition of 846 * IN1-9: "Group Name" at a specific index 847 * 848 * @param rep The repetition index (0-indexed) 849 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 850 */ 851 public XON insertGroupName(int rep) throws HL7Exception { 852 return (XON) super.insertRepetition(9, rep); 853 } 854 855 856 /** 857 * Inserts a repetition of 858 * IN1-9: "Group Name" at a specific index 859 * 860 * @param rep The repetition index (0-indexed) 861 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 862 */ 863 public XON insertIn19_GroupName(int rep) throws HL7Exception { 864 return (XON) super.insertRepetition(9, rep); 865 } 866 867 868 /** 869 * Removes a repetition of 870 * IN1-9: "Group Name" at a specific index 871 * 872 * @param rep The repetition index (0-indexed) 873 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 874 */ 875 public XON removeGroupName(int rep) throws HL7Exception { 876 return (XON) super.removeRepetition(9, rep); 877 } 878 879 880 /** 881 * Removes a repetition of 882 * IN1-9: "Group Name" at a specific index 883 * 884 * @param rep The repetition index (0-indexed) 885 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 886 */ 887 public XON removeIn19_GroupName(int rep) throws HL7Exception { 888 return (XON) super.removeRepetition(9, rep); 889 } 890 891 892 893 /** 894 * Returns all repetitions of Insured's Group Emp ID (IN1-10). 895 */ 896 public CX[] getInsuredSGroupEmpID() { 897 CX[] retVal = this.getTypedField(10, new CX[0]); 898 return retVal; 899 } 900 901 902 /** 903 * Returns all repetitions of Insured's Group Emp ID (IN1-10). 904 */ 905 public CX[] getIn110_InsuredSGroupEmpID() { 906 CX[] retVal = this.getTypedField(10, new CX[0]); 907 return retVal; 908 } 909 910 911 /** 912 * Returns a count of the current number of repetitions of Insured's Group Emp ID (IN1-10). 913 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 914 * it will return zero. 915 */ 916 public int getInsuredSGroupEmpIDReps() { 917 return this.getReps(10); 918 } 919 920 921 /** 922 * Returns a specific repetition of 923 * IN1-10: "Insured's Group Emp ID" - creates it if necessary 924 * 925 * @param rep The repetition index (0-indexed) 926 */ 927 public CX getInsuredSGroupEmpID(int rep) { 928 CX retVal = this.getTypedField(10, rep); 929 return retVal; 930 } 931 932 /** 933 * Returns a specific repetition of 934 * IN1-10: "Insured's Group Emp ID" - creates it if necessary 935 * 936 * @param rep The repetition index (0-indexed) 937 */ 938 public CX getIn110_InsuredSGroupEmpID(int rep) { 939 CX retVal = this.getTypedField(10, rep); 940 return retVal; 941 } 942 943 /** 944 * Returns a count of the current number of repetitions of Insured's Group Emp ID (IN1-10). 945 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 946 * it will return zero. 947 */ 948 public int getIn110_InsuredSGroupEmpIDReps() { 949 return this.getReps(10); 950 } 951 952 953 /** 954 * Inserts a repetition of 955 * IN1-10: "Insured's Group Emp ID" at a specific index 956 * 957 * @param rep The repetition index (0-indexed) 958 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 959 */ 960 public CX insertInsuredSGroupEmpID(int rep) throws HL7Exception { 961 return (CX) super.insertRepetition(10, rep); 962 } 963 964 965 /** 966 * Inserts a repetition of 967 * IN1-10: "Insured's Group Emp ID" at a specific index 968 * 969 * @param rep The repetition index (0-indexed) 970 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 971 */ 972 public CX insertIn110_InsuredSGroupEmpID(int rep) throws HL7Exception { 973 return (CX) super.insertRepetition(10, rep); 974 } 975 976 977 /** 978 * Removes a repetition of 979 * IN1-10: "Insured's Group Emp ID" at a specific index 980 * 981 * @param rep The repetition index (0-indexed) 982 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 983 */ 984 public CX removeInsuredSGroupEmpID(int rep) throws HL7Exception { 985 return (CX) super.removeRepetition(10, rep); 986 } 987 988 989 /** 990 * Removes a repetition of 991 * IN1-10: "Insured's Group Emp ID" at a specific index 992 * 993 * @param rep The repetition index (0-indexed) 994 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 995 */ 996 public CX removeIn110_InsuredSGroupEmpID(int rep) throws HL7Exception { 997 return (CX) super.removeRepetition(10, rep); 998 } 999 1000 1001 1002 /** 1003 * Returns all repetitions of Insured's Group Emp Name (IN1-11). 1004 */ 1005 public XON[] getInsuredSGroupEmpName() { 1006 XON[] retVal = this.getTypedField(11, new XON[0]); 1007 return retVal; 1008 } 1009 1010 1011 /** 1012 * Returns all repetitions of Insured's Group Emp Name (IN1-11). 1013 */ 1014 public XON[] getIn111_InsuredSGroupEmpName() { 1015 XON[] retVal = this.getTypedField(11, new XON[0]); 1016 return retVal; 1017 } 1018 1019 1020 /** 1021 * Returns a count of the current number of repetitions of Insured's Group Emp Name (IN1-11). 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 getInsuredSGroupEmpNameReps() { 1026 return this.getReps(11); 1027 } 1028 1029 1030 /** 1031 * Returns a specific repetition of 1032 * IN1-11: "Insured's Group Emp Name" - creates it if necessary 1033 * 1034 * @param rep The repetition index (0-indexed) 1035 */ 1036 public XON getInsuredSGroupEmpName(int rep) { 1037 XON retVal = this.getTypedField(11, rep); 1038 return retVal; 1039 } 1040 1041 /** 1042 * Returns a specific repetition of 1043 * IN1-11: "Insured's Group Emp Name" - creates it if necessary 1044 * 1045 * @param rep The repetition index (0-indexed) 1046 */ 1047 public XON getIn111_InsuredSGroupEmpName(int rep) { 1048 XON retVal = this.getTypedField(11, rep); 1049 return retVal; 1050 } 1051 1052 /** 1053 * Returns a count of the current number of repetitions of Insured's Group Emp Name (IN1-11). 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 getIn111_InsuredSGroupEmpNameReps() { 1058 return this.getReps(11); 1059 } 1060 1061 1062 /** 1063 * Inserts a repetition of 1064 * IN1-11: "Insured's Group Emp Name" 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 XON insertInsuredSGroupEmpName(int rep) throws HL7Exception { 1070 return (XON) super.insertRepetition(11, rep); 1071 } 1072 1073 1074 /** 1075 * Inserts a repetition of 1076 * IN1-11: "Insured's Group Emp Name" 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 XON insertIn111_InsuredSGroupEmpName(int rep) throws HL7Exception { 1082 return (XON) super.insertRepetition(11, rep); 1083 } 1084 1085 1086 /** 1087 * Removes a repetition of 1088 * IN1-11: "Insured's Group Emp Name" 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 XON removeInsuredSGroupEmpName(int rep) throws HL7Exception { 1094 return (XON) super.removeRepetition(11, rep); 1095 } 1096 1097 1098 /** 1099 * Removes a repetition of 1100 * IN1-11: "Insured's Group Emp Name" 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 XON removeIn111_InsuredSGroupEmpName(int rep) throws HL7Exception { 1106 return (XON) super.removeRepetition(11, rep); 1107 } 1108 1109 1110 1111 1112 /** 1113 * Returns 1114 * IN1-12: "Plan Effective Date" - creates it if necessary 1115 */ 1116 public DT getPlanEffectiveDate() { 1117 DT retVal = this.getTypedField(12, 0); 1118 return retVal; 1119 } 1120 1121 /** 1122 * Returns 1123 * IN1-12: "Plan Effective Date" - creates it if necessary 1124 */ 1125 public DT getIn112_PlanEffectiveDate() { 1126 DT retVal = this.getTypedField(12, 0); 1127 return retVal; 1128 } 1129 1130 1131 1132 /** 1133 * Returns 1134 * IN1-13: "Plan Expiration Date" - creates it if necessary 1135 */ 1136 public DT getPlanExpirationDate() { 1137 DT retVal = this.getTypedField(13, 0); 1138 return retVal; 1139 } 1140 1141 /** 1142 * Returns 1143 * IN1-13: "Plan Expiration Date" - creates it if necessary 1144 */ 1145 public DT getIn113_PlanExpirationDate() { 1146 DT retVal = this.getTypedField(13, 0); 1147 return retVal; 1148 } 1149 1150 1151 1152 /** 1153 * Returns 1154 * IN1-14: "Authorization Information" - creates it if necessary 1155 */ 1156 public AUI getAuthorizationInformation() { 1157 AUI retVal = this.getTypedField(14, 0); 1158 return retVal; 1159 } 1160 1161 /** 1162 * Returns 1163 * IN1-14: "Authorization Information" - creates it if necessary 1164 */ 1165 public AUI getIn114_AuthorizationInformation() { 1166 AUI retVal = this.getTypedField(14, 0); 1167 return retVal; 1168 } 1169 1170 1171 1172 /** 1173 * Returns 1174 * IN1-15: "Plan Type" - creates it if necessary 1175 */ 1176 public IS getPlanType() { 1177 IS retVal = this.getTypedField(15, 0); 1178 return retVal; 1179 } 1180 1181 /** 1182 * Returns 1183 * IN1-15: "Plan Type" - creates it if necessary 1184 */ 1185 public IS getIn115_PlanType() { 1186 IS retVal = this.getTypedField(15, 0); 1187 return retVal; 1188 } 1189 1190 1191 /** 1192 * Returns all repetitions of Name Of Insured (IN1-16). 1193 */ 1194 public XPN[] getNameOfInsured() { 1195 XPN[] retVal = this.getTypedField(16, new XPN[0]); 1196 return retVal; 1197 } 1198 1199 1200 /** 1201 * Returns all repetitions of Name Of Insured (IN1-16). 1202 */ 1203 public XPN[] getIn116_NameOfInsured() { 1204 XPN[] retVal = this.getTypedField(16, new XPN[0]); 1205 return retVal; 1206 } 1207 1208 1209 /** 1210 * Returns a count of the current number of repetitions of Name Of Insured (IN1-16). 1211 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1212 * it will return zero. 1213 */ 1214 public int getNameOfInsuredReps() { 1215 return this.getReps(16); 1216 } 1217 1218 1219 /** 1220 * Returns a specific repetition of 1221 * IN1-16: "Name Of Insured" - creates it if necessary 1222 * 1223 * @param rep The repetition index (0-indexed) 1224 */ 1225 public XPN getNameOfInsured(int rep) { 1226 XPN retVal = this.getTypedField(16, rep); 1227 return retVal; 1228 } 1229 1230 /** 1231 * Returns a specific repetition of 1232 * IN1-16: "Name Of Insured" - creates it if necessary 1233 * 1234 * @param rep The repetition index (0-indexed) 1235 */ 1236 public XPN getIn116_NameOfInsured(int rep) { 1237 XPN retVal = this.getTypedField(16, rep); 1238 return retVal; 1239 } 1240 1241 /** 1242 * Returns a count of the current number of repetitions of Name Of Insured (IN1-16). 1243 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1244 * it will return zero. 1245 */ 1246 public int getIn116_NameOfInsuredReps() { 1247 return this.getReps(16); 1248 } 1249 1250 1251 /** 1252 * Inserts a repetition of 1253 * IN1-16: "Name Of Insured" at a specific index 1254 * 1255 * @param rep The repetition index (0-indexed) 1256 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1257 */ 1258 public XPN insertNameOfInsured(int rep) throws HL7Exception { 1259 return (XPN) super.insertRepetition(16, rep); 1260 } 1261 1262 1263 /** 1264 * Inserts a repetition of 1265 * IN1-16: "Name Of Insured" at a specific index 1266 * 1267 * @param rep The repetition index (0-indexed) 1268 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1269 */ 1270 public XPN insertIn116_NameOfInsured(int rep) throws HL7Exception { 1271 return (XPN) super.insertRepetition(16, rep); 1272 } 1273 1274 1275 /** 1276 * Removes a repetition of 1277 * IN1-16: "Name Of Insured" at a specific index 1278 * 1279 * @param rep The repetition index (0-indexed) 1280 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1281 */ 1282 public XPN removeNameOfInsured(int rep) throws HL7Exception { 1283 return (XPN) super.removeRepetition(16, rep); 1284 } 1285 1286 1287 /** 1288 * Removes a repetition of 1289 * IN1-16: "Name Of Insured" at a specific index 1290 * 1291 * @param rep The repetition index (0-indexed) 1292 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1293 */ 1294 public XPN removeIn116_NameOfInsured(int rep) throws HL7Exception { 1295 return (XPN) super.removeRepetition(16, rep); 1296 } 1297 1298 1299 1300 1301 /** 1302 * Returns 1303 * IN1-17: "Insured's Relationship To Patient" - creates it if necessary 1304 */ 1305 public CE getInsuredSRelationshipToPatient() { 1306 CE retVal = this.getTypedField(17, 0); 1307 return retVal; 1308 } 1309 1310 /** 1311 * Returns 1312 * IN1-17: "Insured's Relationship To Patient" - creates it if necessary 1313 */ 1314 public CE getIn117_InsuredSRelationshipToPatient() { 1315 CE retVal = this.getTypedField(17, 0); 1316 return retVal; 1317 } 1318 1319 1320 1321 /** 1322 * Returns 1323 * IN1-18: "Insured's Date Of Birth" - creates it if necessary 1324 */ 1325 public TS getInsuredSDateOfBirth() { 1326 TS retVal = this.getTypedField(18, 0); 1327 return retVal; 1328 } 1329 1330 /** 1331 * Returns 1332 * IN1-18: "Insured's Date Of Birth" - creates it if necessary 1333 */ 1334 public TS getIn118_InsuredSDateOfBirth() { 1335 TS retVal = this.getTypedField(18, 0); 1336 return retVal; 1337 } 1338 1339 1340 /** 1341 * Returns all repetitions of Insured's Address (IN1-19). 1342 */ 1343 public XAD[] getInsuredSAddress() { 1344 XAD[] retVal = this.getTypedField(19, new XAD[0]); 1345 return retVal; 1346 } 1347 1348 1349 /** 1350 * Returns all repetitions of Insured's Address (IN1-19). 1351 */ 1352 public XAD[] getIn119_InsuredSAddress() { 1353 XAD[] retVal = this.getTypedField(19, new XAD[0]); 1354 return retVal; 1355 } 1356 1357 1358 /** 1359 * Returns a count of the current number of repetitions of Insured's Address (IN1-19). 1360 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1361 * it will return zero. 1362 */ 1363 public int getInsuredSAddressReps() { 1364 return this.getReps(19); 1365 } 1366 1367 1368 /** 1369 * Returns a specific repetition of 1370 * IN1-19: "Insured's Address" - creates it if necessary 1371 * 1372 * @param rep The repetition index (0-indexed) 1373 */ 1374 public XAD getInsuredSAddress(int rep) { 1375 XAD retVal = this.getTypedField(19, rep); 1376 return retVal; 1377 } 1378 1379 /** 1380 * Returns a specific repetition of 1381 * IN1-19: "Insured's Address" - creates it if necessary 1382 * 1383 * @param rep The repetition index (0-indexed) 1384 */ 1385 public XAD getIn119_InsuredSAddress(int rep) { 1386 XAD retVal = this.getTypedField(19, rep); 1387 return retVal; 1388 } 1389 1390 /** 1391 * Returns a count of the current number of repetitions of Insured's Address (IN1-19). 1392 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1393 * it will return zero. 1394 */ 1395 public int getIn119_InsuredSAddressReps() { 1396 return this.getReps(19); 1397 } 1398 1399 1400 /** 1401 * Inserts a repetition of 1402 * IN1-19: "Insured's Address" at a specific index 1403 * 1404 * @param rep The repetition index (0-indexed) 1405 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1406 */ 1407 public XAD insertInsuredSAddress(int rep) throws HL7Exception { 1408 return (XAD) super.insertRepetition(19, rep); 1409 } 1410 1411 1412 /** 1413 * Inserts a repetition of 1414 * IN1-19: "Insured's Address" at a specific index 1415 * 1416 * @param rep The repetition index (0-indexed) 1417 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1418 */ 1419 public XAD insertIn119_InsuredSAddress(int rep) throws HL7Exception { 1420 return (XAD) super.insertRepetition(19, rep); 1421 } 1422 1423 1424 /** 1425 * Removes a repetition of 1426 * IN1-19: "Insured's Address" at a specific index 1427 * 1428 * @param rep The repetition index (0-indexed) 1429 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1430 */ 1431 public XAD removeInsuredSAddress(int rep) throws HL7Exception { 1432 return (XAD) super.removeRepetition(19, rep); 1433 } 1434 1435 1436 /** 1437 * Removes a repetition of 1438 * IN1-19: "Insured's Address" at a specific index 1439 * 1440 * @param rep The repetition index (0-indexed) 1441 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1442 */ 1443 public XAD removeIn119_InsuredSAddress(int rep) throws HL7Exception { 1444 return (XAD) super.removeRepetition(19, rep); 1445 } 1446 1447 1448 1449 1450 /** 1451 * Returns 1452 * IN1-20: "Assignment Of Benefits" - creates it if necessary 1453 */ 1454 public IS getAssignmentOfBenefits() { 1455 IS retVal = this.getTypedField(20, 0); 1456 return retVal; 1457 } 1458 1459 /** 1460 * Returns 1461 * IN1-20: "Assignment Of Benefits" - creates it if necessary 1462 */ 1463 public IS getIn120_AssignmentOfBenefits() { 1464 IS retVal = this.getTypedField(20, 0); 1465 return retVal; 1466 } 1467 1468 1469 1470 /** 1471 * Returns 1472 * IN1-21: "Coordination Of Benefits" - creates it if necessary 1473 */ 1474 public IS getCoordinationOfBenefits() { 1475 IS retVal = this.getTypedField(21, 0); 1476 return retVal; 1477 } 1478 1479 /** 1480 * Returns 1481 * IN1-21: "Coordination Of Benefits" - creates it if necessary 1482 */ 1483 public IS getIn121_CoordinationOfBenefits() { 1484 IS retVal = this.getTypedField(21, 0); 1485 return retVal; 1486 } 1487 1488 1489 1490 /** 1491 * Returns 1492 * IN1-22: "Coord Of Ben. Priority" - creates it if necessary 1493 */ 1494 public ST getCoordOfBenPriority() { 1495 ST retVal = this.getTypedField(22, 0); 1496 return retVal; 1497 } 1498 1499 /** 1500 * Returns 1501 * IN1-22: "Coord Of Ben. Priority" - creates it if necessary 1502 */ 1503 public ST getIn122_CoordOfBenPriority() { 1504 ST retVal = this.getTypedField(22, 0); 1505 return retVal; 1506 } 1507 1508 1509 1510 /** 1511 * Returns 1512 * IN1-23: "Notice Of Admission Flag" - creates it if necessary 1513 */ 1514 public ID getNoticeOfAdmissionFlag() { 1515 ID retVal = this.getTypedField(23, 0); 1516 return retVal; 1517 } 1518 1519 /** 1520 * Returns 1521 * IN1-23: "Notice Of Admission Flag" - creates it if necessary 1522 */ 1523 public ID getIn123_NoticeOfAdmissionFlag() { 1524 ID retVal = this.getTypedField(23, 0); 1525 return retVal; 1526 } 1527 1528 1529 1530 /** 1531 * Returns 1532 * IN1-24: "Notice Of Admission Date" - creates it if necessary 1533 */ 1534 public DT getNoticeOfAdmissionDate() { 1535 DT retVal = this.getTypedField(24, 0); 1536 return retVal; 1537 } 1538 1539 /** 1540 * Returns 1541 * IN1-24: "Notice Of Admission Date" - creates it if necessary 1542 */ 1543 public DT getIn124_NoticeOfAdmissionDate() { 1544 DT retVal = this.getTypedField(24, 0); 1545 return retVal; 1546 } 1547 1548 1549 1550 /** 1551 * Returns 1552 * IN1-25: "Report Of Eligibility Flag" - creates it if necessary 1553 */ 1554 public ID getReportOfEligibilityFlag() { 1555 ID retVal = this.getTypedField(25, 0); 1556 return retVal; 1557 } 1558 1559 /** 1560 * Returns 1561 * IN1-25: "Report Of Eligibility Flag" - creates it if necessary 1562 */ 1563 public ID getIn125_ReportOfEligibilityFlag() { 1564 ID retVal = this.getTypedField(25, 0); 1565 return retVal; 1566 } 1567 1568 1569 1570 /** 1571 * Returns 1572 * IN1-26: "Report Of Eligibility Date" - creates it if necessary 1573 */ 1574 public DT getReportOfEligibilityDate() { 1575 DT retVal = this.getTypedField(26, 0); 1576 return retVal; 1577 } 1578 1579 /** 1580 * Returns 1581 * IN1-26: "Report Of Eligibility Date" - creates it if necessary 1582 */ 1583 public DT getIn126_ReportOfEligibilityDate() { 1584 DT retVal = this.getTypedField(26, 0); 1585 return retVal; 1586 } 1587 1588 1589 1590 /** 1591 * Returns 1592 * IN1-27: "Release Information Code" - creates it if necessary 1593 */ 1594 public IS getReleaseInformationCode() { 1595 IS retVal = this.getTypedField(27, 0); 1596 return retVal; 1597 } 1598 1599 /** 1600 * Returns 1601 * IN1-27: "Release Information Code" - creates it if necessary 1602 */ 1603 public IS getIn127_ReleaseInformationCode() { 1604 IS retVal = this.getTypedField(27, 0); 1605 return retVal; 1606 } 1607 1608 1609 1610 /** 1611 * Returns 1612 * IN1-28: "Pre-Admit Cert (PAC)" - creates it if necessary 1613 */ 1614 public ST getPreAdmitCert() { 1615 ST retVal = this.getTypedField(28, 0); 1616 return retVal; 1617 } 1618 1619 /** 1620 * Returns 1621 * IN1-28: "Pre-Admit Cert (PAC)" - creates it if necessary 1622 */ 1623 public ST getIn128_PreAdmitCert() { 1624 ST retVal = this.getTypedField(28, 0); 1625 return retVal; 1626 } 1627 1628 1629 1630 /** 1631 * Returns 1632 * IN1-29: "Verification Date/Time" - creates it if necessary 1633 */ 1634 public TS getVerificationDateTime() { 1635 TS retVal = this.getTypedField(29, 0); 1636 return retVal; 1637 } 1638 1639 /** 1640 * Returns 1641 * IN1-29: "Verification Date/Time" - creates it if necessary 1642 */ 1643 public TS getIn129_VerificationDateTime() { 1644 TS retVal = this.getTypedField(29, 0); 1645 return retVal; 1646 } 1647 1648 1649 /** 1650 * Returns all repetitions of Verification By (IN1-30). 1651 */ 1652 public XCN[] getVerificationBy() { 1653 XCN[] retVal = this.getTypedField(30, new XCN[0]); 1654 return retVal; 1655 } 1656 1657 1658 /** 1659 * Returns all repetitions of Verification By (IN1-30). 1660 */ 1661 public XCN[] getIn130_VerificationBy() { 1662 XCN[] retVal = this.getTypedField(30, new XCN[0]); 1663 return retVal; 1664 } 1665 1666 1667 /** 1668 * Returns a count of the current number of repetitions of Verification By (IN1-30). 1669 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1670 * it will return zero. 1671 */ 1672 public int getVerificationByReps() { 1673 return this.getReps(30); 1674 } 1675 1676 1677 /** 1678 * Returns a specific repetition of 1679 * IN1-30: "Verification By" - creates it if necessary 1680 * 1681 * @param rep The repetition index (0-indexed) 1682 */ 1683 public XCN getVerificationBy(int rep) { 1684 XCN retVal = this.getTypedField(30, rep); 1685 return retVal; 1686 } 1687 1688 /** 1689 * Returns a specific repetition of 1690 * IN1-30: "Verification By" - creates it if necessary 1691 * 1692 * @param rep The repetition index (0-indexed) 1693 */ 1694 public XCN getIn130_VerificationBy(int rep) { 1695 XCN retVal = this.getTypedField(30, rep); 1696 return retVal; 1697 } 1698 1699 /** 1700 * Returns a count of the current number of repetitions of Verification By (IN1-30). 1701 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1702 * it will return zero. 1703 */ 1704 public int getIn130_VerificationByReps() { 1705 return this.getReps(30); 1706 } 1707 1708 1709 /** 1710 * Inserts a repetition of 1711 * IN1-30: "Verification By" at a specific index 1712 * 1713 * @param rep The repetition index (0-indexed) 1714 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1715 */ 1716 public XCN insertVerificationBy(int rep) throws HL7Exception { 1717 return (XCN) super.insertRepetition(30, rep); 1718 } 1719 1720 1721 /** 1722 * Inserts a repetition of 1723 * IN1-30: "Verification By" at a specific index 1724 * 1725 * @param rep The repetition index (0-indexed) 1726 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1727 */ 1728 public XCN insertIn130_VerificationBy(int rep) throws HL7Exception { 1729 return (XCN) super.insertRepetition(30, rep); 1730 } 1731 1732 1733 /** 1734 * Removes a repetition of 1735 * IN1-30: "Verification By" at a specific index 1736 * 1737 * @param rep The repetition index (0-indexed) 1738 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1739 */ 1740 public XCN removeVerificationBy(int rep) throws HL7Exception { 1741 return (XCN) super.removeRepetition(30, rep); 1742 } 1743 1744 1745 /** 1746 * Removes a repetition of 1747 * IN1-30: "Verification By" at a specific index 1748 * 1749 * @param rep The repetition index (0-indexed) 1750 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1751 */ 1752 public XCN removeIn130_VerificationBy(int rep) throws HL7Exception { 1753 return (XCN) super.removeRepetition(30, rep); 1754 } 1755 1756 1757 1758 1759 /** 1760 * Returns 1761 * IN1-31: "Type Of Agreement Code" - creates it if necessary 1762 */ 1763 public IS getTypeOfAgreementCode() { 1764 IS retVal = this.getTypedField(31, 0); 1765 return retVal; 1766 } 1767 1768 /** 1769 * Returns 1770 * IN1-31: "Type Of Agreement Code" - creates it if necessary 1771 */ 1772 public IS getIn131_TypeOfAgreementCode() { 1773 IS retVal = this.getTypedField(31, 0); 1774 return retVal; 1775 } 1776 1777 1778 1779 /** 1780 * Returns 1781 * IN1-32: "Billing Status" - creates it if necessary 1782 */ 1783 public IS getBillingStatus() { 1784 IS retVal = this.getTypedField(32, 0); 1785 return retVal; 1786 } 1787 1788 /** 1789 * Returns 1790 * IN1-32: "Billing Status" - creates it if necessary 1791 */ 1792 public IS getIn132_BillingStatus() { 1793 IS retVal = this.getTypedField(32, 0); 1794 return retVal; 1795 } 1796 1797 1798 1799 /** 1800 * Returns 1801 * IN1-33: "Lifetime Reserve Days" - creates it if necessary 1802 */ 1803 public NM getLifetimeReserveDays() { 1804 NM retVal = this.getTypedField(33, 0); 1805 return retVal; 1806 } 1807 1808 /** 1809 * Returns 1810 * IN1-33: "Lifetime Reserve Days" - creates it if necessary 1811 */ 1812 public NM getIn133_LifetimeReserveDays() { 1813 NM retVal = this.getTypedField(33, 0); 1814 return retVal; 1815 } 1816 1817 1818 1819 /** 1820 * Returns 1821 * IN1-34: "Delay Before L.R. Day" - creates it if necessary 1822 */ 1823 public NM getDelayBeforeLRDay() { 1824 NM retVal = this.getTypedField(34, 0); 1825 return retVal; 1826 } 1827 1828 /** 1829 * Returns 1830 * IN1-34: "Delay Before L.R. Day" - creates it if necessary 1831 */ 1832 public NM getIn134_DelayBeforeLRDay() { 1833 NM retVal = this.getTypedField(34, 0); 1834 return retVal; 1835 } 1836 1837 1838 1839 /** 1840 * Returns 1841 * IN1-35: "Company Plan Code" - creates it if necessary 1842 */ 1843 public IS getCompanyPlanCode() { 1844 IS retVal = this.getTypedField(35, 0); 1845 return retVal; 1846 } 1847 1848 /** 1849 * Returns 1850 * IN1-35: "Company Plan Code" - creates it if necessary 1851 */ 1852 public IS getIn135_CompanyPlanCode() { 1853 IS retVal = this.getTypedField(35, 0); 1854 return retVal; 1855 } 1856 1857 1858 1859 /** 1860 * Returns 1861 * IN1-36: "Policy Number" - creates it if necessary 1862 */ 1863 public ST getPolicyNumber() { 1864 ST retVal = this.getTypedField(36, 0); 1865 return retVal; 1866 } 1867 1868 /** 1869 * Returns 1870 * IN1-36: "Policy Number" - creates it if necessary 1871 */ 1872 public ST getIn136_PolicyNumber() { 1873 ST retVal = this.getTypedField(36, 0); 1874 return retVal; 1875 } 1876 1877 1878 1879 /** 1880 * Returns 1881 * IN1-37: "Policy Deductible" - creates it if necessary 1882 */ 1883 public CP getPolicyDeductible() { 1884 CP retVal = this.getTypedField(37, 0); 1885 return retVal; 1886 } 1887 1888 /** 1889 * Returns 1890 * IN1-37: "Policy Deductible" - creates it if necessary 1891 */ 1892 public CP getIn137_PolicyDeductible() { 1893 CP retVal = this.getTypedField(37, 0); 1894 return retVal; 1895 } 1896 1897 1898 1899 /** 1900 * Returns 1901 * IN1-38: "Policy Limit - Amount" - creates it if necessary 1902 */ 1903 public CP getPolicyLimitAmount() { 1904 CP retVal = this.getTypedField(38, 0); 1905 return retVal; 1906 } 1907 1908 /** 1909 * Returns 1910 * IN1-38: "Policy Limit - Amount" - creates it if necessary 1911 */ 1912 public CP getIn138_PolicyLimitAmount() { 1913 CP retVal = this.getTypedField(38, 0); 1914 return retVal; 1915 } 1916 1917 1918 1919 /** 1920 * Returns 1921 * IN1-39: "Policy Limit - Days" - creates it if necessary 1922 */ 1923 public NM getPolicyLimitDays() { 1924 NM retVal = this.getTypedField(39, 0); 1925 return retVal; 1926 } 1927 1928 /** 1929 * Returns 1930 * IN1-39: "Policy Limit - Days" - creates it if necessary 1931 */ 1932 public NM getIn139_PolicyLimitDays() { 1933 NM retVal = this.getTypedField(39, 0); 1934 return retVal; 1935 } 1936 1937 1938 1939 /** 1940 * Returns 1941 * IN1-40: "Room Rate - Semi-Private" - creates it if necessary 1942 */ 1943 public CP getRoomRateSemiPrivate() { 1944 CP retVal = this.getTypedField(40, 0); 1945 return retVal; 1946 } 1947 1948 /** 1949 * Returns 1950 * IN1-40: "Room Rate - Semi-Private" - creates it if necessary 1951 */ 1952 public CP getIn140_RoomRateSemiPrivate() { 1953 CP retVal = this.getTypedField(40, 0); 1954 return retVal; 1955 } 1956 1957 1958 1959 /** 1960 * Returns 1961 * IN1-41: "Room Rate - Private" - creates it if necessary 1962 */ 1963 public CP getRoomRatePrivate() { 1964 CP retVal = this.getTypedField(41, 0); 1965 return retVal; 1966 } 1967 1968 /** 1969 * Returns 1970 * IN1-41: "Room Rate - Private" - creates it if necessary 1971 */ 1972 public CP getIn141_RoomRatePrivate() { 1973 CP retVal = this.getTypedField(41, 0); 1974 return retVal; 1975 } 1976 1977 1978 1979 /** 1980 * Returns 1981 * IN1-42: "Insured's Employment Status" - creates it if necessary 1982 */ 1983 public CE getInsuredSEmploymentStatus() { 1984 CE retVal = this.getTypedField(42, 0); 1985 return retVal; 1986 } 1987 1988 /** 1989 * Returns 1990 * IN1-42: "Insured's Employment Status" - creates it if necessary 1991 */ 1992 public CE getIn142_InsuredSEmploymentStatus() { 1993 CE retVal = this.getTypedField(42, 0); 1994 return retVal; 1995 } 1996 1997 1998 1999 /** 2000 * Returns 2001 * IN1-43: "Insured's Administrative Sex" - creates it if necessary 2002 */ 2003 public IS getInsuredSAdministrativeSex() { 2004 IS retVal = this.getTypedField(43, 0); 2005 return retVal; 2006 } 2007 2008 /** 2009 * Returns 2010 * IN1-43: "Insured's Administrative Sex" - creates it if necessary 2011 */ 2012 public IS getIn143_InsuredSAdministrativeSex() { 2013 IS retVal = this.getTypedField(43, 0); 2014 return retVal; 2015 } 2016 2017 2018 /** 2019 * Returns all repetitions of Insured's Employer's Address (IN1-44). 2020 */ 2021 public XAD[] getInsuredSEmployerSAddress() { 2022 XAD[] retVal = this.getTypedField(44, new XAD[0]); 2023 return retVal; 2024 } 2025 2026 2027 /** 2028 * Returns all repetitions of Insured's Employer's Address (IN1-44). 2029 */ 2030 public XAD[] getIn144_InsuredSEmployerSAddress() { 2031 XAD[] retVal = this.getTypedField(44, new XAD[0]); 2032 return retVal; 2033 } 2034 2035 2036 /** 2037 * Returns a count of the current number of repetitions of Insured's Employer's Address (IN1-44). 2038 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2039 * it will return zero. 2040 */ 2041 public int getInsuredSEmployerSAddressReps() { 2042 return this.getReps(44); 2043 } 2044 2045 2046 /** 2047 * Returns a specific repetition of 2048 * IN1-44: "Insured's Employer's Address" - creates it if necessary 2049 * 2050 * @param rep The repetition index (0-indexed) 2051 */ 2052 public XAD getInsuredSEmployerSAddress(int rep) { 2053 XAD retVal = this.getTypedField(44, rep); 2054 return retVal; 2055 } 2056 2057 /** 2058 * Returns a specific repetition of 2059 * IN1-44: "Insured's Employer's Address" - creates it if necessary 2060 * 2061 * @param rep The repetition index (0-indexed) 2062 */ 2063 public XAD getIn144_InsuredSEmployerSAddress(int rep) { 2064 XAD retVal = this.getTypedField(44, rep); 2065 return retVal; 2066 } 2067 2068 /** 2069 * Returns a count of the current number of repetitions of Insured's Employer's Address (IN1-44). 2070 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2071 * it will return zero. 2072 */ 2073 public int getIn144_InsuredSEmployerSAddressReps() { 2074 return this.getReps(44); 2075 } 2076 2077 2078 /** 2079 * Inserts a repetition of 2080 * IN1-44: "Insured's Employer's Address" at a specific index 2081 * 2082 * @param rep The repetition index (0-indexed) 2083 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2084 */ 2085 public XAD insertInsuredSEmployerSAddress(int rep) throws HL7Exception { 2086 return (XAD) super.insertRepetition(44, rep); 2087 } 2088 2089 2090 /** 2091 * Inserts a repetition of 2092 * IN1-44: "Insured's Employer's Address" at a specific index 2093 * 2094 * @param rep The repetition index (0-indexed) 2095 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2096 */ 2097 public XAD insertIn144_InsuredSEmployerSAddress(int rep) throws HL7Exception { 2098 return (XAD) super.insertRepetition(44, rep); 2099 } 2100 2101 2102 /** 2103 * Removes a repetition of 2104 * IN1-44: "Insured's Employer's Address" at a specific index 2105 * 2106 * @param rep The repetition index (0-indexed) 2107 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2108 */ 2109 public XAD removeInsuredSEmployerSAddress(int rep) throws HL7Exception { 2110 return (XAD) super.removeRepetition(44, rep); 2111 } 2112 2113 2114 /** 2115 * Removes a repetition of 2116 * IN1-44: "Insured's Employer's Address" at a specific index 2117 * 2118 * @param rep The repetition index (0-indexed) 2119 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2120 */ 2121 public XAD removeIn144_InsuredSEmployerSAddress(int rep) throws HL7Exception { 2122 return (XAD) super.removeRepetition(44, rep); 2123 } 2124 2125 2126 2127 2128 /** 2129 * Returns 2130 * IN1-45: "Verification Status" - creates it if necessary 2131 */ 2132 public ST getVerificationStatus() { 2133 ST retVal = this.getTypedField(45, 0); 2134 return retVal; 2135 } 2136 2137 /** 2138 * Returns 2139 * IN1-45: "Verification Status" - creates it if necessary 2140 */ 2141 public ST getIn145_VerificationStatus() { 2142 ST retVal = this.getTypedField(45, 0); 2143 return retVal; 2144 } 2145 2146 2147 2148 /** 2149 * Returns 2150 * IN1-46: "Prior Insurance Plan ID" - creates it if necessary 2151 */ 2152 public IS getPriorInsurancePlanID() { 2153 IS retVal = this.getTypedField(46, 0); 2154 return retVal; 2155 } 2156 2157 /** 2158 * Returns 2159 * IN1-46: "Prior Insurance Plan ID" - creates it if necessary 2160 */ 2161 public IS getIn146_PriorInsurancePlanID() { 2162 IS retVal = this.getTypedField(46, 0); 2163 return retVal; 2164 } 2165 2166 2167 2168 /** 2169 * Returns 2170 * IN1-47: "Coverage Type" - creates it if necessary 2171 */ 2172 public IS getCoverageType() { 2173 IS retVal = this.getTypedField(47, 0); 2174 return retVal; 2175 } 2176 2177 /** 2178 * Returns 2179 * IN1-47: "Coverage Type" - creates it if necessary 2180 */ 2181 public IS getIn147_CoverageType() { 2182 IS retVal = this.getTypedField(47, 0); 2183 return retVal; 2184 } 2185 2186 2187 2188 /** 2189 * Returns 2190 * IN1-48: "Handicap" - creates it if necessary 2191 */ 2192 public IS getHandicap() { 2193 IS retVal = this.getTypedField(48, 0); 2194 return retVal; 2195 } 2196 2197 /** 2198 * Returns 2199 * IN1-48: "Handicap" - creates it if necessary 2200 */ 2201 public IS getIn148_Handicap() { 2202 IS retVal = this.getTypedField(48, 0); 2203 return retVal; 2204 } 2205 2206 2207 /** 2208 * Returns all repetitions of Insured's ID Number (IN1-49). 2209 */ 2210 public CX[] getInsuredSIDNumber() { 2211 CX[] retVal = this.getTypedField(49, new CX[0]); 2212 return retVal; 2213 } 2214 2215 2216 /** 2217 * Returns all repetitions of Insured's ID Number (IN1-49). 2218 */ 2219 public CX[] getIn149_InsuredSIDNumber() { 2220 CX[] retVal = this.getTypedField(49, new CX[0]); 2221 return retVal; 2222 } 2223 2224 2225 /** 2226 * Returns a count of the current number of repetitions of Insured's ID Number (IN1-49). 2227 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2228 * it will return zero. 2229 */ 2230 public int getInsuredSIDNumberReps() { 2231 return this.getReps(49); 2232 } 2233 2234 2235 /** 2236 * Returns a specific repetition of 2237 * IN1-49: "Insured's ID Number" - creates it if necessary 2238 * 2239 * @param rep The repetition index (0-indexed) 2240 */ 2241 public CX getInsuredSIDNumber(int rep) { 2242 CX retVal = this.getTypedField(49, rep); 2243 return retVal; 2244 } 2245 2246 /** 2247 * Returns a specific repetition of 2248 * IN1-49: "Insured's ID Number" - creates it if necessary 2249 * 2250 * @param rep The repetition index (0-indexed) 2251 */ 2252 public CX getIn149_InsuredSIDNumber(int rep) { 2253 CX retVal = this.getTypedField(49, rep); 2254 return retVal; 2255 } 2256 2257 /** 2258 * Returns a count of the current number of repetitions of Insured's ID Number (IN1-49). 2259 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2260 * it will return zero. 2261 */ 2262 public int getIn149_InsuredSIDNumberReps() { 2263 return this.getReps(49); 2264 } 2265 2266 2267 /** 2268 * Inserts a repetition of 2269 * IN1-49: "Insured's ID Number" at a specific index 2270 * 2271 * @param rep The repetition index (0-indexed) 2272 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2273 */ 2274 public CX insertInsuredSIDNumber(int rep) throws HL7Exception { 2275 return (CX) super.insertRepetition(49, rep); 2276 } 2277 2278 2279 /** 2280 * Inserts a repetition of 2281 * IN1-49: "Insured's ID Number" at a specific index 2282 * 2283 * @param rep The repetition index (0-indexed) 2284 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2285 */ 2286 public CX insertIn149_InsuredSIDNumber(int rep) throws HL7Exception { 2287 return (CX) super.insertRepetition(49, rep); 2288 } 2289 2290 2291 /** 2292 * Removes a repetition of 2293 * IN1-49: "Insured's ID Number" at a specific index 2294 * 2295 * @param rep The repetition index (0-indexed) 2296 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2297 */ 2298 public CX removeInsuredSIDNumber(int rep) throws HL7Exception { 2299 return (CX) super.removeRepetition(49, rep); 2300 } 2301 2302 2303 /** 2304 * Removes a repetition of 2305 * IN1-49: "Insured's ID Number" at a specific index 2306 * 2307 * @param rep The repetition index (0-indexed) 2308 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2309 */ 2310 public CX removeIn149_InsuredSIDNumber(int rep) throws HL7Exception { 2311 return (CX) super.removeRepetition(49, rep); 2312 } 2313 2314 2315 2316 2317 /** 2318 * Returns 2319 * IN1-50: "Signature Code" - creates it if necessary 2320 */ 2321 public IS getSignatureCode() { 2322 IS retVal = this.getTypedField(50, 0); 2323 return retVal; 2324 } 2325 2326 /** 2327 * Returns 2328 * IN1-50: "Signature Code" - creates it if necessary 2329 */ 2330 public IS getIn150_SignatureCode() { 2331 IS retVal = this.getTypedField(50, 0); 2332 return retVal; 2333 } 2334 2335 2336 2337 /** 2338 * Returns 2339 * IN1-51: "Signature Code Date" - creates it if necessary 2340 */ 2341 public DT getSignatureCodeDate() { 2342 DT retVal = this.getTypedField(51, 0); 2343 return retVal; 2344 } 2345 2346 /** 2347 * Returns 2348 * IN1-51: "Signature Code Date" - creates it if necessary 2349 */ 2350 public DT getIn151_SignatureCodeDate() { 2351 DT retVal = this.getTypedField(51, 0); 2352 return retVal; 2353 } 2354 2355 2356 2357 /** 2358 * Returns 2359 * IN1-52: "Insured's Birth Place" - creates it if necessary 2360 */ 2361 public ST getInsuredSBirthPlace() { 2362 ST retVal = this.getTypedField(52, 0); 2363 return retVal; 2364 } 2365 2366 /** 2367 * Returns 2368 * IN1-52: "Insured's Birth Place" - creates it if necessary 2369 */ 2370 public ST getIn152_InsuredSBirthPlace() { 2371 ST retVal = this.getTypedField(52, 0); 2372 return retVal; 2373 } 2374 2375 2376 2377 /** 2378 * Returns 2379 * IN1-53: "VIP Indicator" - creates it if necessary 2380 */ 2381 public IS getVIPIndicator() { 2382 IS retVal = this.getTypedField(53, 0); 2383 return retVal; 2384 } 2385 2386 /** 2387 * Returns 2388 * IN1-53: "VIP Indicator" - creates it if necessary 2389 */ 2390 public IS getIn153_VIPIndicator() { 2391 IS retVal = this.getTypedField(53, 0); 2392 return retVal; 2393 } 2394 2395 2396 2397 2398 2399 /** {@inheritDoc} */ 2400 protected Type createNewTypeWithoutReflection(int field) { 2401 switch (field) { 2402 case 0: return new SI(getMessage()); 2403 case 1: return new CE(getMessage()); 2404 case 2: return new CX(getMessage()); 2405 case 3: return new XON(getMessage()); 2406 case 4: return new XAD(getMessage()); 2407 case 5: return new XPN(getMessage()); 2408 case 6: return new XTN(getMessage()); 2409 case 7: return new ST(getMessage()); 2410 case 8: return new XON(getMessage()); 2411 case 9: return new CX(getMessage()); 2412 case 10: return new XON(getMessage()); 2413 case 11: return new DT(getMessage()); 2414 case 12: return new DT(getMessage()); 2415 case 13: return new AUI(getMessage()); 2416 case 14: return new IS(getMessage(), new Integer( 86 )); 2417 case 15: return new XPN(getMessage()); 2418 case 16: return new CE(getMessage()); 2419 case 17: return new TS(getMessage()); 2420 case 18: return new XAD(getMessage()); 2421 case 19: return new IS(getMessage(), new Integer( 135 )); 2422 case 20: return new IS(getMessage(), new Integer( 173 )); 2423 case 21: return new ST(getMessage()); 2424 case 22: return new ID(getMessage(), new Integer( 136 )); 2425 case 23: return new DT(getMessage()); 2426 case 24: return new ID(getMessage(), new Integer( 136 )); 2427 case 25: return new DT(getMessage()); 2428 case 26: return new IS(getMessage(), new Integer( 93 )); 2429 case 27: return new ST(getMessage()); 2430 case 28: return new TS(getMessage()); 2431 case 29: return new XCN(getMessage()); 2432 case 30: return new IS(getMessage(), new Integer( 98 )); 2433 case 31: return new IS(getMessage(), new Integer( 22 )); 2434 case 32: return new NM(getMessage()); 2435 case 33: return new NM(getMessage()); 2436 case 34: return new IS(getMessage(), new Integer( 42 )); 2437 case 35: return new ST(getMessage()); 2438 case 36: return new CP(getMessage()); 2439 case 37: return new CP(getMessage()); 2440 case 38: return new NM(getMessage()); 2441 case 39: return new CP(getMessage()); 2442 case 40: return new CP(getMessage()); 2443 case 41: return new CE(getMessage()); 2444 case 42: return new IS(getMessage(), new Integer( 1 )); 2445 case 43: return new XAD(getMessage()); 2446 case 44: return new ST(getMessage()); 2447 case 45: return new IS(getMessage(), new Integer( 72 )); 2448 case 46: return new IS(getMessage(), new Integer( 309 )); 2449 case 47: return new IS(getMessage(), new Integer( 295 )); 2450 case 48: return new CX(getMessage()); 2451 case 49: return new IS(getMessage(), new Integer( 535 )); 2452 case 50: return new DT(getMessage()); 2453 case 51: return new ST(getMessage()); 2454 case 52: return new IS(getMessage(), new Integer( 99 )); 2455 default: return null; 2456 } 2457 } 2458 2459 2460} 2461