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