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