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.v23.segment; 035 036// import ca.uhn.hl7v2.model.v23.group.*; 037import ca.uhn.hl7v2.model.v23.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 NK1 message segment (Next of kin). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>NK1-1: Set ID - Next of Kin (SI) <b> </b> 053 * <li>NK1-2: NK Name (XPN) <b>optional repeating</b> 054 * <li>NK1-3: Relationship (CE) <b>optional </b> 055 * <li>NK1-4: Address (XAD) <b>optional repeating</b> 056 * <li>NK1-5: Phone Number (XTN) <b>optional repeating</b> 057 * <li>NK1-6: Business Phone Number (XTN) <b>optional repeating</b> 058 * <li>NK1-7: Contact Role (CE) <b> </b> 059 * <li>NK1-8: Start Date (DT) <b>optional </b> 060 * <li>NK1-9: End Date (DT) <b>optional </b> 061 * <li>NK1-10: Next of Kin/Associated Parties Job Title (ST) <b>optional </b> 062 * <li>NK1-11: Next of Kin Job/Associated Parties Code/Class (JCC) <b>optional </b> 063 * <li>NK1-12: Next of Kin/Associated Parties Employee Number (CX) <b>optional </b> 064 * <li>NK1-13: Organization Name (XON) <b>optional repeating</b> 065 * <li>NK1-14: Marital Status (IS) <b>optional repeating</b> 066 * <li>NK1-15: Sex (IS) <b>optional </b> 067 * <li>NK1-16: Date of Birth (TS) <b>optional </b> 068 * <li>NK1-17: Living Dependency (IS) <b>optional </b> 069 * <li>NK1-18: Ambulatory Status (IS) <b>optional </b> 070 * <li>NK1-19: Citizenship (IS) <b>optional </b> 071 * <li>NK1-20: Primary Language (CE) <b>optional </b> 072 * <li>NK1-21: Living Arrangement (IS) <b>optional </b> 073 * <li>NK1-22: Publicity Indicator (CE) <b>optional </b> 074 * <li>NK1-23: Protection Indicator (ID) <b>optional </b> 075 * <li>NK1-24: Student Indicator (IS) <b>optional </b> 076 * <li>NK1-25: Religion (IS) <b>optional </b> 077 * <li>NK1-26: Mother’s Maiden Name (XPN) <b>optional </b> 078 * <li>NK1-27: Nationality Code (CE) <b>optional </b> 079 * <li>NK1-28: Ethnic Group (IS) <b>optional </b> 080 * <li>NK1-29: Contact Reason (CE) <b>optional </b> 081 * <li>NK1-30: Contact Person's Name (XPN) <b>optional repeating</b> 082 * <li>NK1-31: Contact Person’s Telephone Number (XTN) <b>optional repeating</b> 083 * <li>NK1-32: Contact Person’s Address (XAD) <b>optional repeating</b> 084 * <li>NK1-33: Associated Party’s Identifiers (CX) <b>optional repeating</b> 085 * <li>NK1-34: Job Status (IS) <b>optional </b> 086 * <li>NK1-35: Race (IS) <b>optional </b> 087 * <li>NK1-36: Handicap (IS) <b>optional </b> 088 * <li>NK1-37: Contact Person Social Security Number (ST) <b>optional </b> 089 * </ul> 090 */ 091@SuppressWarnings("unused") 092public class NK1 extends AbstractSegment { 093 094 /** 095 * Creates a new NK1 segment 096 */ 097 public NK1(Group parent, ModelClassFactory factory) { 098 super(parent, factory); 099 init(factory); 100 } 101 102 private void init(ModelClassFactory factory) { 103 try { 104 this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - Next of Kin"); 105 this.add(XPN.class, false, 0, 48, new Object[]{ getMessage() }, "NK Name"); 106 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Relationship"); 107 this.add(XAD.class, false, 0, 106, new Object[]{ getMessage() }, "Address"); 108 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone Number"); 109 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Business Phone Number"); 110 this.add(CE.class, true, 1, 60, new Object[]{ getMessage() }, "Contact Role"); 111 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Start Date"); 112 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "End Date"); 113 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Next of Kin/Associated Parties Job Title"); 114 this.add(JCC.class, false, 1, 20, new Object[]{ getMessage() }, "Next of Kin Job/Associated Parties Code/Class"); 115 this.add(CX.class, false, 1, 20, new Object[]{ getMessage() }, "Next of Kin/Associated Parties Employee Number"); 116 this.add(XON.class, false, 0, 60, new Object[]{ getMessage() }, "Organization Name"); 117 this.add(IS.class, false, 0, 1, new Object[]{ getMessage(), new Integer(2) }, "Marital Status"); 118 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Sex"); 119 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date of Birth"); 120 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(223) }, "Living Dependency"); 121 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(9) }, "Ambulatory Status"); 122 this.add(IS.class, false, 1, 4, new Object[]{ getMessage(), new Integer(171) }, "Citizenship"); 123 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Primary Language"); 124 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(220) }, "Living Arrangement"); 125 this.add(CE.class, false, 1, 1, new Object[]{ getMessage() }, "Publicity Indicator"); 126 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Protection Indicator"); 127 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(231) }, "Student Indicator"); 128 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(6) }, "Religion"); 129 this.add(XPN.class, false, 1, 48, new Object[]{ getMessage() }, "Mother’s Maiden Name"); 130 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Nationality Code"); 131 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(189) }, "Ethnic Group"); 132 this.add(CE.class, false, 1, 2, new Object[]{ getMessage() }, "Contact Reason"); 133 this.add(XPN.class, false, 0, 48, new Object[]{ getMessage() }, "Contact Person's Name"); 134 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Contact Person’s Telephone Number"); 135 this.add(XAD.class, false, 0, 106, new Object[]{ getMessage() }, "Contact Person’s Address"); 136 this.add(CX.class, false, 0, 32, new Object[]{ getMessage() }, "Associated Party’s Identifiers"); 137 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(311) }, "Job Status"); 138 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(5) }, "Race"); 139 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(310) }, "Handicap"); 140 this.add(ST.class, false, 1, 16, new Object[]{ getMessage() }, "Contact Person Social Security Number"); 141 } catch(HL7Exception e) { 142 log.error("Unexpected error creating NK1 - this is probably a bug in the source code generator.", e); 143 } 144 } 145 146 147 148 /** 149 * Returns 150 * NK1-1: "Set ID - Next of Kin" - creates it if necessary 151 */ 152 public SI getSetIDNextOfKin() { 153 SI retVal = this.getTypedField(1, 0); 154 return retVal; 155 } 156 157 /** 158 * Returns 159 * NK1-1: "Set ID - Next of Kin" - creates it if necessary 160 */ 161 public SI getNk11_SetIDNextOfKin() { 162 SI retVal = this.getTypedField(1, 0); 163 return retVal; 164 } 165 166 167 /** 168 * Returns all repetitions of NK Name (NK1-2). 169 */ 170 public XPN[] getNKName() { 171 XPN[] retVal = this.getTypedField(2, new XPN[0]); 172 return retVal; 173 } 174 175 176 /** 177 * Returns all repetitions of NK Name (NK1-2). 178 */ 179 public XPN[] getNk12_NKName() { 180 XPN[] retVal = this.getTypedField(2, new XPN[0]); 181 return retVal; 182 } 183 184 185 /** 186 * Returns a count of the current number of repetitions of NK Name (NK1-2). 187 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 188 * it will return zero. 189 */ 190 public int getNKNameReps() { 191 return this.getReps(2); 192 } 193 194 195 /** 196 * Returns a specific repetition of 197 * NK1-2: "NK Name" - creates it if necessary 198 * 199 * @param rep The repetition index (0-indexed) 200 */ 201 public XPN getNKName(int rep) { 202 XPN retVal = this.getTypedField(2, rep); 203 return retVal; 204 } 205 206 /** 207 * Returns a specific repetition of 208 * NK1-2: "NK Name" - creates it if necessary 209 * 210 * @param rep The repetition index (0-indexed) 211 */ 212 public XPN getNk12_NKName(int rep) { 213 XPN retVal = this.getTypedField(2, rep); 214 return retVal; 215 } 216 217 /** 218 * Returns a count of the current number of repetitions of NK Name (NK1-2). 219 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 220 * it will return zero. 221 */ 222 public int getNk12_NKNameReps() { 223 return this.getReps(2); 224 } 225 226 227 /** 228 * Inserts a repetition of 229 * NK1-2: "NK Name" at a specific index 230 * 231 * @param rep The repetition index (0-indexed) 232 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 233 */ 234 public XPN insertNKName(int rep) throws HL7Exception { 235 return (XPN) super.insertRepetition(2, rep); 236 } 237 238 239 /** 240 * Inserts a repetition of 241 * NK1-2: "NK Name" at a specific index 242 * 243 * @param rep The repetition index (0-indexed) 244 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 245 */ 246 public XPN insertNk12_NKName(int rep) throws HL7Exception { 247 return (XPN) super.insertRepetition(2, rep); 248 } 249 250 251 /** 252 * Removes a repetition of 253 * NK1-2: "NK Name" at a specific index 254 * 255 * @param rep The repetition index (0-indexed) 256 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 257 */ 258 public XPN removeNKName(int rep) throws HL7Exception { 259 return (XPN) super.removeRepetition(2, rep); 260 } 261 262 263 /** 264 * Removes a repetition of 265 * NK1-2: "NK Name" at a specific index 266 * 267 * @param rep The repetition index (0-indexed) 268 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 269 */ 270 public XPN removeNk12_NKName(int rep) throws HL7Exception { 271 return (XPN) super.removeRepetition(2, rep); 272 } 273 274 275 276 277 /** 278 * Returns 279 * NK1-3: "Relationship" - creates it if necessary 280 */ 281 public CE getRelationship() { 282 CE retVal = this.getTypedField(3, 0); 283 return retVal; 284 } 285 286 /** 287 * Returns 288 * NK1-3: "Relationship" - creates it if necessary 289 */ 290 public CE getNk13_Relationship() { 291 CE retVal = this.getTypedField(3, 0); 292 return retVal; 293 } 294 295 296 /** 297 * Returns all repetitions of Address (NK1-4). 298 */ 299 public XAD[] getAddress() { 300 XAD[] retVal = this.getTypedField(4, new XAD[0]); 301 return retVal; 302 } 303 304 305 /** 306 * Returns all repetitions of Address (NK1-4). 307 */ 308 public XAD[] getNk14_Address() { 309 XAD[] retVal = this.getTypedField(4, new XAD[0]); 310 return retVal; 311 } 312 313 314 /** 315 * Returns a count of the current number of repetitions of Address (NK1-4). 316 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 317 * it will return zero. 318 */ 319 public int getAddressReps() { 320 return this.getReps(4); 321 } 322 323 324 /** 325 * Returns a specific repetition of 326 * NK1-4: "Address" - creates it if necessary 327 * 328 * @param rep The repetition index (0-indexed) 329 */ 330 public XAD getAddress(int rep) { 331 XAD retVal = this.getTypedField(4, rep); 332 return retVal; 333 } 334 335 /** 336 * Returns a specific repetition of 337 * NK1-4: "Address" - creates it if necessary 338 * 339 * @param rep The repetition index (0-indexed) 340 */ 341 public XAD getNk14_Address(int rep) { 342 XAD retVal = this.getTypedField(4, rep); 343 return retVal; 344 } 345 346 /** 347 * Returns a count of the current number of repetitions of Address (NK1-4). 348 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 349 * it will return zero. 350 */ 351 public int getNk14_AddressReps() { 352 return this.getReps(4); 353 } 354 355 356 /** 357 * Inserts a repetition of 358 * NK1-4: "Address" at a specific index 359 * 360 * @param rep The repetition index (0-indexed) 361 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 362 */ 363 public XAD insertAddress(int rep) throws HL7Exception { 364 return (XAD) super.insertRepetition(4, rep); 365 } 366 367 368 /** 369 * Inserts a repetition of 370 * NK1-4: "Address" at a specific index 371 * 372 * @param rep The repetition index (0-indexed) 373 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 374 */ 375 public XAD insertNk14_Address(int rep) throws HL7Exception { 376 return (XAD) super.insertRepetition(4, rep); 377 } 378 379 380 /** 381 * Removes a repetition of 382 * NK1-4: "Address" at a specific index 383 * 384 * @param rep The repetition index (0-indexed) 385 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 386 */ 387 public XAD removeAddress(int rep) throws HL7Exception { 388 return (XAD) super.removeRepetition(4, rep); 389 } 390 391 392 /** 393 * Removes a repetition of 394 * NK1-4: "Address" at a specific index 395 * 396 * @param rep The repetition index (0-indexed) 397 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 398 */ 399 public XAD removeNk14_Address(int rep) throws HL7Exception { 400 return (XAD) super.removeRepetition(4, rep); 401 } 402 403 404 405 /** 406 * Returns all repetitions of Phone Number (NK1-5). 407 */ 408 public XTN[] getPhoneNumber() { 409 XTN[] retVal = this.getTypedField(5, new XTN[0]); 410 return retVal; 411 } 412 413 414 /** 415 * Returns all repetitions of Phone Number (NK1-5). 416 */ 417 public XTN[] getNk15_PhoneNumber() { 418 XTN[] retVal = this.getTypedField(5, new XTN[0]); 419 return retVal; 420 } 421 422 423 /** 424 * Returns a count of the current number of repetitions of Phone Number (NK1-5). 425 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 426 * it will return zero. 427 */ 428 public int getPhoneNumberReps() { 429 return this.getReps(5); 430 } 431 432 433 /** 434 * Returns a specific repetition of 435 * NK1-5: "Phone Number" - creates it if necessary 436 * 437 * @param rep The repetition index (0-indexed) 438 */ 439 public XTN getPhoneNumber(int rep) { 440 XTN retVal = this.getTypedField(5, rep); 441 return retVal; 442 } 443 444 /** 445 * Returns a specific repetition of 446 * NK1-5: "Phone Number" - creates it if necessary 447 * 448 * @param rep The repetition index (0-indexed) 449 */ 450 public XTN getNk15_PhoneNumber(int rep) { 451 XTN retVal = this.getTypedField(5, rep); 452 return retVal; 453 } 454 455 /** 456 * Returns a count of the current number of repetitions of Phone Number (NK1-5). 457 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 458 * it will return zero. 459 */ 460 public int getNk15_PhoneNumberReps() { 461 return this.getReps(5); 462 } 463 464 465 /** 466 * Inserts a repetition of 467 * NK1-5: "Phone Number" at a specific index 468 * 469 * @param rep The repetition index (0-indexed) 470 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 471 */ 472 public XTN insertPhoneNumber(int rep) throws HL7Exception { 473 return (XTN) super.insertRepetition(5, rep); 474 } 475 476 477 /** 478 * Inserts a repetition of 479 * NK1-5: "Phone Number" at a specific index 480 * 481 * @param rep The repetition index (0-indexed) 482 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 483 */ 484 public XTN insertNk15_PhoneNumber(int rep) throws HL7Exception { 485 return (XTN) super.insertRepetition(5, rep); 486 } 487 488 489 /** 490 * Removes a repetition of 491 * NK1-5: "Phone Number" at a specific index 492 * 493 * @param rep The repetition index (0-indexed) 494 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 495 */ 496 public XTN removePhoneNumber(int rep) throws HL7Exception { 497 return (XTN) super.removeRepetition(5, rep); 498 } 499 500 501 /** 502 * Removes a repetition of 503 * NK1-5: "Phone Number" at a specific index 504 * 505 * @param rep The repetition index (0-indexed) 506 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 507 */ 508 public XTN removeNk15_PhoneNumber(int rep) throws HL7Exception { 509 return (XTN) super.removeRepetition(5, rep); 510 } 511 512 513 514 /** 515 * Returns all repetitions of Business Phone Number (NK1-6). 516 */ 517 public XTN[] getBusinessPhoneNumber() { 518 XTN[] retVal = this.getTypedField(6, new XTN[0]); 519 return retVal; 520 } 521 522 523 /** 524 * Returns all repetitions of Business Phone Number (NK1-6). 525 */ 526 public XTN[] getNk16_BusinessPhoneNumber() { 527 XTN[] retVal = this.getTypedField(6, new XTN[0]); 528 return retVal; 529 } 530 531 532 /** 533 * Returns a count of the current number of repetitions of Business Phone Number (NK1-6). 534 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 535 * it will return zero. 536 */ 537 public int getBusinessPhoneNumberReps() { 538 return this.getReps(6); 539 } 540 541 542 /** 543 * Returns a specific repetition of 544 * NK1-6: "Business Phone Number" - creates it if necessary 545 * 546 * @param rep The repetition index (0-indexed) 547 */ 548 public XTN getBusinessPhoneNumber(int rep) { 549 XTN retVal = this.getTypedField(6, rep); 550 return retVal; 551 } 552 553 /** 554 * Returns a specific repetition of 555 * NK1-6: "Business Phone Number" - creates it if necessary 556 * 557 * @param rep The repetition index (0-indexed) 558 */ 559 public XTN getNk16_BusinessPhoneNumber(int rep) { 560 XTN retVal = this.getTypedField(6, rep); 561 return retVal; 562 } 563 564 /** 565 * Returns a count of the current number of repetitions of Business Phone Number (NK1-6). 566 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 567 * it will return zero. 568 */ 569 public int getNk16_BusinessPhoneNumberReps() { 570 return this.getReps(6); 571 } 572 573 574 /** 575 * Inserts a repetition of 576 * NK1-6: "Business Phone Number" at a specific index 577 * 578 * @param rep The repetition index (0-indexed) 579 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 580 */ 581 public XTN insertBusinessPhoneNumber(int rep) throws HL7Exception { 582 return (XTN) super.insertRepetition(6, rep); 583 } 584 585 586 /** 587 * Inserts a repetition of 588 * NK1-6: "Business Phone Number" at a specific index 589 * 590 * @param rep The repetition index (0-indexed) 591 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 592 */ 593 public XTN insertNk16_BusinessPhoneNumber(int rep) throws HL7Exception { 594 return (XTN) super.insertRepetition(6, rep); 595 } 596 597 598 /** 599 * Removes a repetition of 600 * NK1-6: "Business Phone Number" at a specific index 601 * 602 * @param rep The repetition index (0-indexed) 603 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 604 */ 605 public XTN removeBusinessPhoneNumber(int rep) throws HL7Exception { 606 return (XTN) super.removeRepetition(6, rep); 607 } 608 609 610 /** 611 * Removes a repetition of 612 * NK1-6: "Business Phone Number" at a specific index 613 * 614 * @param rep The repetition index (0-indexed) 615 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 616 */ 617 public XTN removeNk16_BusinessPhoneNumber(int rep) throws HL7Exception { 618 return (XTN) super.removeRepetition(6, rep); 619 } 620 621 622 623 624 /** 625 * Returns 626 * NK1-7: "Contact Role" - creates it if necessary 627 */ 628 public CE getContactRole() { 629 CE retVal = this.getTypedField(7, 0); 630 return retVal; 631 } 632 633 /** 634 * Returns 635 * NK1-7: "Contact Role" - creates it if necessary 636 */ 637 public CE getNk17_ContactRole() { 638 CE retVal = this.getTypedField(7, 0); 639 return retVal; 640 } 641 642 643 644 /** 645 * Returns 646 * NK1-8: "Start Date" - creates it if necessary 647 */ 648 public DT getStartDate() { 649 DT retVal = this.getTypedField(8, 0); 650 return retVal; 651 } 652 653 /** 654 * Returns 655 * NK1-8: "Start Date" - creates it if necessary 656 */ 657 public DT getNk18_StartDate() { 658 DT retVal = this.getTypedField(8, 0); 659 return retVal; 660 } 661 662 663 664 /** 665 * Returns 666 * NK1-9: "End Date" - creates it if necessary 667 */ 668 public DT getEndDate() { 669 DT retVal = this.getTypedField(9, 0); 670 return retVal; 671 } 672 673 /** 674 * Returns 675 * NK1-9: "End Date" - creates it if necessary 676 */ 677 public DT getNk19_EndDate() { 678 DT retVal = this.getTypedField(9, 0); 679 return retVal; 680 } 681 682 683 684 /** 685 * Returns 686 * NK1-10: "Next of Kin/Associated Parties Job Title" - creates it if necessary 687 */ 688 public ST getNextOfKinAssociatedPartiesJobTitle() { 689 ST retVal = this.getTypedField(10, 0); 690 return retVal; 691 } 692 693 /** 694 * Returns 695 * NK1-10: "Next of Kin/Associated Parties Job Title" - creates it if necessary 696 */ 697 public ST getNk110_NextOfKinAssociatedPartiesJobTitle() { 698 ST retVal = this.getTypedField(10, 0); 699 return retVal; 700 } 701 702 703 704 /** 705 * Returns 706 * NK1-11: "Next of Kin Job/Associated Parties Code/Class" - creates it if necessary 707 */ 708 public JCC getNextOfKinJobAssociatedPartiesCodeClass() { 709 JCC retVal = this.getTypedField(11, 0); 710 return retVal; 711 } 712 713 /** 714 * Returns 715 * NK1-11: "Next of Kin Job/Associated Parties Code/Class" - creates it if necessary 716 */ 717 public JCC getNk111_NextOfKinJobAssociatedPartiesCodeClass() { 718 JCC retVal = this.getTypedField(11, 0); 719 return retVal; 720 } 721 722 723 724 /** 725 * Returns 726 * NK1-12: "Next of Kin/Associated Parties Employee Number" - creates it if necessary 727 */ 728 public CX getNextOfKinAssociatedPartiesEmployeeNumber() { 729 CX retVal = this.getTypedField(12, 0); 730 return retVal; 731 } 732 733 /** 734 * Returns 735 * NK1-12: "Next of Kin/Associated Parties Employee Number" - creates it if necessary 736 */ 737 public CX getNk112_NextOfKinAssociatedPartiesEmployeeNumber() { 738 CX retVal = this.getTypedField(12, 0); 739 return retVal; 740 } 741 742 743 /** 744 * Returns all repetitions of Organization Name (NK1-13). 745 */ 746 public XON[] getOrganizationName() { 747 XON[] retVal = this.getTypedField(13, new XON[0]); 748 return retVal; 749 } 750 751 752 /** 753 * Returns all repetitions of Organization Name (NK1-13). 754 */ 755 public XON[] getNk113_OrganizationName() { 756 XON[] retVal = this.getTypedField(13, new XON[0]); 757 return retVal; 758 } 759 760 761 /** 762 * Returns a count of the current number of repetitions of Organization Name (NK1-13). 763 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 764 * it will return zero. 765 */ 766 public int getOrganizationNameReps() { 767 return this.getReps(13); 768 } 769 770 771 /** 772 * Returns a specific repetition of 773 * NK1-13: "Organization Name" - creates it if necessary 774 * 775 * @param rep The repetition index (0-indexed) 776 */ 777 public XON getOrganizationName(int rep) { 778 XON retVal = this.getTypedField(13, rep); 779 return retVal; 780 } 781 782 /** 783 * Returns a specific repetition of 784 * NK1-13: "Organization Name" - creates it if necessary 785 * 786 * @param rep The repetition index (0-indexed) 787 */ 788 public XON getNk113_OrganizationName(int rep) { 789 XON retVal = this.getTypedField(13, rep); 790 return retVal; 791 } 792 793 /** 794 * Returns a count of the current number of repetitions of Organization Name (NK1-13). 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 getNk113_OrganizationNameReps() { 799 return this.getReps(13); 800 } 801 802 803 /** 804 * Inserts a repetition of 805 * NK1-13: "Organization Name" at a specific index 806 * 807 * @param rep The repetition index (0-indexed) 808 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 809 */ 810 public XON insertOrganizationName(int rep) throws HL7Exception { 811 return (XON) super.insertRepetition(13, rep); 812 } 813 814 815 /** 816 * Inserts a repetition of 817 * NK1-13: "Organization Name" at a specific index 818 * 819 * @param rep The repetition index (0-indexed) 820 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 821 */ 822 public XON insertNk113_OrganizationName(int rep) throws HL7Exception { 823 return (XON) super.insertRepetition(13, rep); 824 } 825 826 827 /** 828 * Removes a repetition of 829 * NK1-13: "Organization Name" at a specific index 830 * 831 * @param rep The repetition index (0-indexed) 832 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 833 */ 834 public XON removeOrganizationName(int rep) throws HL7Exception { 835 return (XON) super.removeRepetition(13, rep); 836 } 837 838 839 /** 840 * Removes a repetition of 841 * NK1-13: "Organization Name" at a specific index 842 * 843 * @param rep The repetition index (0-indexed) 844 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 845 */ 846 public XON removeNk113_OrganizationName(int rep) throws HL7Exception { 847 return (XON) super.removeRepetition(13, rep); 848 } 849 850 851 852 /** 853 * Returns all repetitions of Marital Status (NK1-14). 854 */ 855 public IS[] getMaritalStatus() { 856 IS[] retVal = this.getTypedField(14, new IS[0]); 857 return retVal; 858 } 859 860 861 /** 862 * Returns all repetitions of Marital Status (NK1-14). 863 */ 864 public IS[] getNk114_MaritalStatus() { 865 IS[] retVal = this.getTypedField(14, new IS[0]); 866 return retVal; 867 } 868 869 870 /** 871 * Returns a count of the current number of repetitions of Marital Status (NK1-14). 872 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 873 * it will return zero. 874 */ 875 public int getMaritalStatusReps() { 876 return this.getReps(14); 877 } 878 879 880 /** 881 * Returns a specific repetition of 882 * NK1-14: "Marital Status" - creates it if necessary 883 * 884 * @param rep The repetition index (0-indexed) 885 */ 886 public IS getMaritalStatus(int rep) { 887 IS retVal = this.getTypedField(14, rep); 888 return retVal; 889 } 890 891 /** 892 * Returns a specific repetition of 893 * NK1-14: "Marital Status" - creates it if necessary 894 * 895 * @param rep The repetition index (0-indexed) 896 */ 897 public IS getNk114_MaritalStatus(int rep) { 898 IS retVal = this.getTypedField(14, rep); 899 return retVal; 900 } 901 902 /** 903 * Returns a count of the current number of repetitions of Marital Status (NK1-14). 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 getNk114_MaritalStatusReps() { 908 return this.getReps(14); 909 } 910 911 912 /** 913 * Inserts a repetition of 914 * NK1-14: "Marital Status" at a specific index 915 * 916 * @param rep The repetition index (0-indexed) 917 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 918 */ 919 public IS insertMaritalStatus(int rep) throws HL7Exception { 920 return (IS) super.insertRepetition(14, rep); 921 } 922 923 924 /** 925 * Inserts a repetition of 926 * NK1-14: "Marital Status" at a specific index 927 * 928 * @param rep The repetition index (0-indexed) 929 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 930 */ 931 public IS insertNk114_MaritalStatus(int rep) throws HL7Exception { 932 return (IS) super.insertRepetition(14, rep); 933 } 934 935 936 /** 937 * Removes a repetition of 938 * NK1-14: "Marital Status" at a specific index 939 * 940 * @param rep The repetition index (0-indexed) 941 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 942 */ 943 public IS removeMaritalStatus(int rep) throws HL7Exception { 944 return (IS) super.removeRepetition(14, rep); 945 } 946 947 948 /** 949 * Removes a repetition of 950 * NK1-14: "Marital Status" at a specific index 951 * 952 * @param rep The repetition index (0-indexed) 953 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 954 */ 955 public IS removeNk114_MaritalStatus(int rep) throws HL7Exception { 956 return (IS) super.removeRepetition(14, rep); 957 } 958 959 960 961 962 /** 963 * Returns 964 * NK1-15: "Sex" - creates it if necessary 965 */ 966 public IS getSex() { 967 IS retVal = this.getTypedField(15, 0); 968 return retVal; 969 } 970 971 /** 972 * Returns 973 * NK1-15: "Sex" - creates it if necessary 974 */ 975 public IS getNk115_Sex() { 976 IS retVal = this.getTypedField(15, 0); 977 return retVal; 978 } 979 980 981 982 /** 983 * Returns 984 * NK1-16: "Date of Birth" - creates it if necessary 985 */ 986 public TS getDateOfBirth() { 987 TS retVal = this.getTypedField(16, 0); 988 return retVal; 989 } 990 991 /** 992 * Returns 993 * NK1-16: "Date of Birth" - creates it if necessary 994 */ 995 public TS getNk116_DateOfBirth() { 996 TS retVal = this.getTypedField(16, 0); 997 return retVal; 998 } 999 1000 1001 1002 /** 1003 * Returns 1004 * NK1-17: "Living Dependency" - creates it if necessary 1005 */ 1006 public IS getLivingDependency() { 1007 IS retVal = this.getTypedField(17, 0); 1008 return retVal; 1009 } 1010 1011 /** 1012 * Returns 1013 * NK1-17: "Living Dependency" - creates it if necessary 1014 */ 1015 public IS getNk117_LivingDependency() { 1016 IS retVal = this.getTypedField(17, 0); 1017 return retVal; 1018 } 1019 1020 1021 1022 /** 1023 * Returns 1024 * NK1-18: "Ambulatory Status" - creates it if necessary 1025 */ 1026 public IS getAmbulatoryStatus() { 1027 IS retVal = this.getTypedField(18, 0); 1028 return retVal; 1029 } 1030 1031 /** 1032 * Returns 1033 * NK1-18: "Ambulatory Status" - creates it if necessary 1034 */ 1035 public IS getNk118_AmbulatoryStatus() { 1036 IS retVal = this.getTypedField(18, 0); 1037 return retVal; 1038 } 1039 1040 1041 1042 /** 1043 * Returns 1044 * NK1-19: "Citizenship" - creates it if necessary 1045 */ 1046 public IS getCitizenship() { 1047 IS retVal = this.getTypedField(19, 0); 1048 return retVal; 1049 } 1050 1051 /** 1052 * Returns 1053 * NK1-19: "Citizenship" - creates it if necessary 1054 */ 1055 public IS getNk119_Citizenship() { 1056 IS retVal = this.getTypedField(19, 0); 1057 return retVal; 1058 } 1059 1060 1061 1062 /** 1063 * Returns 1064 * NK1-20: "Primary Language" - creates it if necessary 1065 */ 1066 public CE getPrimaryLanguage() { 1067 CE retVal = this.getTypedField(20, 0); 1068 return retVal; 1069 } 1070 1071 /** 1072 * Returns 1073 * NK1-20: "Primary Language" - creates it if necessary 1074 */ 1075 public CE getNk120_PrimaryLanguage() { 1076 CE retVal = this.getTypedField(20, 0); 1077 return retVal; 1078 } 1079 1080 1081 1082 /** 1083 * Returns 1084 * NK1-21: "Living Arrangement" - creates it if necessary 1085 */ 1086 public IS getLivingArrangement() { 1087 IS retVal = this.getTypedField(21, 0); 1088 return retVal; 1089 } 1090 1091 /** 1092 * Returns 1093 * NK1-21: "Living Arrangement" - creates it if necessary 1094 */ 1095 public IS getNk121_LivingArrangement() { 1096 IS retVal = this.getTypedField(21, 0); 1097 return retVal; 1098 } 1099 1100 1101 1102 /** 1103 * Returns 1104 * NK1-22: "Publicity Indicator" - creates it if necessary 1105 */ 1106 public CE getPublicityIndicator() { 1107 CE retVal = this.getTypedField(22, 0); 1108 return retVal; 1109 } 1110 1111 /** 1112 * Returns 1113 * NK1-22: "Publicity Indicator" - creates it if necessary 1114 */ 1115 public CE getNk122_PublicityIndicator() { 1116 CE retVal = this.getTypedField(22, 0); 1117 return retVal; 1118 } 1119 1120 1121 1122 /** 1123 * Returns 1124 * NK1-23: "Protection Indicator" - creates it if necessary 1125 */ 1126 public ID getProtectionIndicator() { 1127 ID retVal = this.getTypedField(23, 0); 1128 return retVal; 1129 } 1130 1131 /** 1132 * Returns 1133 * NK1-23: "Protection Indicator" - creates it if necessary 1134 */ 1135 public ID getNk123_ProtectionIndicator() { 1136 ID retVal = this.getTypedField(23, 0); 1137 return retVal; 1138 } 1139 1140 1141 1142 /** 1143 * Returns 1144 * NK1-24: "Student Indicator" - creates it if necessary 1145 */ 1146 public IS getStudentIndicator() { 1147 IS retVal = this.getTypedField(24, 0); 1148 return retVal; 1149 } 1150 1151 /** 1152 * Returns 1153 * NK1-24: "Student Indicator" - creates it if necessary 1154 */ 1155 public IS getNk124_StudentIndicator() { 1156 IS retVal = this.getTypedField(24, 0); 1157 return retVal; 1158 } 1159 1160 1161 1162 /** 1163 * Returns 1164 * NK1-25: "Religion" - creates it if necessary 1165 */ 1166 public IS getReligion() { 1167 IS retVal = this.getTypedField(25, 0); 1168 return retVal; 1169 } 1170 1171 /** 1172 * Returns 1173 * NK1-25: "Religion" - creates it if necessary 1174 */ 1175 public IS getNk125_Religion() { 1176 IS retVal = this.getTypedField(25, 0); 1177 return retVal; 1178 } 1179 1180 1181 1182 /** 1183 * Returns 1184 * NK1-26: "Mother’s Maiden Name" - creates it if necessary 1185 */ 1186 public XPN getMotherSMaidenName() { 1187 XPN retVal = this.getTypedField(26, 0); 1188 return retVal; 1189 } 1190 1191 /** 1192 * Returns 1193 * NK1-26: "Mother’s Maiden Name" - creates it if necessary 1194 */ 1195 public XPN getNk126_MotherSMaidenName() { 1196 XPN retVal = this.getTypedField(26, 0); 1197 return retVal; 1198 } 1199 1200 1201 1202 /** 1203 * Returns 1204 * NK1-27: "Nationality Code" - creates it if necessary 1205 */ 1206 public CE getNationalityCode() { 1207 CE retVal = this.getTypedField(27, 0); 1208 return retVal; 1209 } 1210 1211 /** 1212 * Returns 1213 * NK1-27: "Nationality Code" - creates it if necessary 1214 */ 1215 public CE getNk127_NationalityCode() { 1216 CE retVal = this.getTypedField(27, 0); 1217 return retVal; 1218 } 1219 1220 1221 1222 /** 1223 * Returns 1224 * NK1-28: "Ethnic Group" - creates it if necessary 1225 */ 1226 public IS getEthnicGroup() { 1227 IS retVal = this.getTypedField(28, 0); 1228 return retVal; 1229 } 1230 1231 /** 1232 * Returns 1233 * NK1-28: "Ethnic Group" - creates it if necessary 1234 */ 1235 public IS getNk128_EthnicGroup() { 1236 IS retVal = this.getTypedField(28, 0); 1237 return retVal; 1238 } 1239 1240 1241 1242 /** 1243 * Returns 1244 * NK1-29: "Contact Reason" - creates it if necessary 1245 */ 1246 public CE getContactReason() { 1247 CE retVal = this.getTypedField(29, 0); 1248 return retVal; 1249 } 1250 1251 /** 1252 * Returns 1253 * NK1-29: "Contact Reason" - creates it if necessary 1254 */ 1255 public CE getNk129_ContactReason() { 1256 CE retVal = this.getTypedField(29, 0); 1257 return retVal; 1258 } 1259 1260 1261 /** 1262 * Returns all repetitions of Contact Person's Name (NK1-30). 1263 */ 1264 public XPN[] getContactPersonSName() { 1265 XPN[] retVal = this.getTypedField(30, new XPN[0]); 1266 return retVal; 1267 } 1268 1269 1270 /** 1271 * Returns all repetitions of Contact Person's Name (NK1-30). 1272 */ 1273 public XPN[] getNk130_ContactPersonSName() { 1274 XPN[] retVal = this.getTypedField(30, new XPN[0]); 1275 return retVal; 1276 } 1277 1278 1279 /** 1280 * Returns a count of the current number of repetitions of Contact Person's Name (NK1-30). 1281 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1282 * it will return zero. 1283 */ 1284 public int getContactPersonSNameReps() { 1285 return this.getReps(30); 1286 } 1287 1288 1289 /** 1290 * Returns a specific repetition of 1291 * NK1-30: "Contact Person's Name" - creates it if necessary 1292 * 1293 * @param rep The repetition index (0-indexed) 1294 */ 1295 public XPN getContactPersonSName(int rep) { 1296 XPN retVal = this.getTypedField(30, rep); 1297 return retVal; 1298 } 1299 1300 /** 1301 * Returns a specific repetition of 1302 * NK1-30: "Contact Person's Name" - creates it if necessary 1303 * 1304 * @param rep The repetition index (0-indexed) 1305 */ 1306 public XPN getNk130_ContactPersonSName(int rep) { 1307 XPN retVal = this.getTypedField(30, rep); 1308 return retVal; 1309 } 1310 1311 /** 1312 * Returns a count of the current number of repetitions of Contact Person's Name (NK1-30). 1313 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1314 * it will return zero. 1315 */ 1316 public int getNk130_ContactPersonSNameReps() { 1317 return this.getReps(30); 1318 } 1319 1320 1321 /** 1322 * Inserts a repetition of 1323 * NK1-30: "Contact Person's Name" at a specific index 1324 * 1325 * @param rep The repetition index (0-indexed) 1326 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1327 */ 1328 public XPN insertContactPersonSName(int rep) throws HL7Exception { 1329 return (XPN) super.insertRepetition(30, rep); 1330 } 1331 1332 1333 /** 1334 * Inserts a repetition of 1335 * NK1-30: "Contact Person's Name" at a specific index 1336 * 1337 * @param rep The repetition index (0-indexed) 1338 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1339 */ 1340 public XPN insertNk130_ContactPersonSName(int rep) throws HL7Exception { 1341 return (XPN) super.insertRepetition(30, rep); 1342 } 1343 1344 1345 /** 1346 * Removes a repetition of 1347 * NK1-30: "Contact Person's Name" at a specific index 1348 * 1349 * @param rep The repetition index (0-indexed) 1350 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1351 */ 1352 public XPN removeContactPersonSName(int rep) throws HL7Exception { 1353 return (XPN) super.removeRepetition(30, rep); 1354 } 1355 1356 1357 /** 1358 * Removes a repetition of 1359 * NK1-30: "Contact Person's Name" at a specific index 1360 * 1361 * @param rep The repetition index (0-indexed) 1362 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1363 */ 1364 public XPN removeNk130_ContactPersonSName(int rep) throws HL7Exception { 1365 return (XPN) super.removeRepetition(30, rep); 1366 } 1367 1368 1369 1370 /** 1371 * Returns all repetitions of Contact Person’s Telephone Number (NK1-31). 1372 */ 1373 public XTN[] getContactPersonSTelephoneNumber() { 1374 XTN[] retVal = this.getTypedField(31, new XTN[0]); 1375 return retVal; 1376 } 1377 1378 1379 /** 1380 * Returns all repetitions of Contact Person’s Telephone Number (NK1-31). 1381 */ 1382 public XTN[] getNk131_ContactPersonSTelephoneNumber() { 1383 XTN[] retVal = this.getTypedField(31, new XTN[0]); 1384 return retVal; 1385 } 1386 1387 1388 /** 1389 * Returns a count of the current number of repetitions of Contact Person’s Telephone Number (NK1-31). 1390 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1391 * it will return zero. 1392 */ 1393 public int getContactPersonSTelephoneNumberReps() { 1394 return this.getReps(31); 1395 } 1396 1397 1398 /** 1399 * Returns a specific repetition of 1400 * NK1-31: "Contact Person’s Telephone Number" - creates it if necessary 1401 * 1402 * @param rep The repetition index (0-indexed) 1403 */ 1404 public XTN getContactPersonSTelephoneNumber(int rep) { 1405 XTN retVal = this.getTypedField(31, rep); 1406 return retVal; 1407 } 1408 1409 /** 1410 * Returns a specific repetition of 1411 * NK1-31: "Contact Person’s Telephone Number" - creates it if necessary 1412 * 1413 * @param rep The repetition index (0-indexed) 1414 */ 1415 public XTN getNk131_ContactPersonSTelephoneNumber(int rep) { 1416 XTN retVal = this.getTypedField(31, rep); 1417 return retVal; 1418 } 1419 1420 /** 1421 * Returns a count of the current number of repetitions of Contact Person’s Telephone Number (NK1-31). 1422 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1423 * it will return zero. 1424 */ 1425 public int getNk131_ContactPersonSTelephoneNumberReps() { 1426 return this.getReps(31); 1427 } 1428 1429 1430 /** 1431 * Inserts a repetition of 1432 * NK1-31: "Contact Person’s Telephone Number" at a specific index 1433 * 1434 * @param rep The repetition index (0-indexed) 1435 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1436 */ 1437 public XTN insertContactPersonSTelephoneNumber(int rep) throws HL7Exception { 1438 return (XTN) super.insertRepetition(31, rep); 1439 } 1440 1441 1442 /** 1443 * Inserts a repetition of 1444 * NK1-31: "Contact Person’s Telephone Number" at a specific index 1445 * 1446 * @param rep The repetition index (0-indexed) 1447 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1448 */ 1449 public XTN insertNk131_ContactPersonSTelephoneNumber(int rep) throws HL7Exception { 1450 return (XTN) super.insertRepetition(31, rep); 1451 } 1452 1453 1454 /** 1455 * Removes a repetition of 1456 * NK1-31: "Contact Person’s Telephone Number" at a specific index 1457 * 1458 * @param rep The repetition index (0-indexed) 1459 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1460 */ 1461 public XTN removeContactPersonSTelephoneNumber(int rep) throws HL7Exception { 1462 return (XTN) super.removeRepetition(31, rep); 1463 } 1464 1465 1466 /** 1467 * Removes a repetition of 1468 * NK1-31: "Contact Person’s Telephone Number" at a specific index 1469 * 1470 * @param rep The repetition index (0-indexed) 1471 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1472 */ 1473 public XTN removeNk131_ContactPersonSTelephoneNumber(int rep) throws HL7Exception { 1474 return (XTN) super.removeRepetition(31, rep); 1475 } 1476 1477 1478 1479 /** 1480 * Returns all repetitions of Contact Person’s Address (NK1-32). 1481 */ 1482 public XAD[] getContactPersonSAddress() { 1483 XAD[] retVal = this.getTypedField(32, new XAD[0]); 1484 return retVal; 1485 } 1486 1487 1488 /** 1489 * Returns all repetitions of Contact Person’s Address (NK1-32). 1490 */ 1491 public XAD[] getNk132_ContactPersonSAddress() { 1492 XAD[] retVal = this.getTypedField(32, new XAD[0]); 1493 return retVal; 1494 } 1495 1496 1497 /** 1498 * Returns a count of the current number of repetitions of Contact Person’s Address (NK1-32). 1499 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1500 * it will return zero. 1501 */ 1502 public int getContactPersonSAddressReps() { 1503 return this.getReps(32); 1504 } 1505 1506 1507 /** 1508 * Returns a specific repetition of 1509 * NK1-32: "Contact Person’s Address" - creates it if necessary 1510 * 1511 * @param rep The repetition index (0-indexed) 1512 */ 1513 public XAD getContactPersonSAddress(int rep) { 1514 XAD retVal = this.getTypedField(32, rep); 1515 return retVal; 1516 } 1517 1518 /** 1519 * Returns a specific repetition of 1520 * NK1-32: "Contact Person’s Address" - creates it if necessary 1521 * 1522 * @param rep The repetition index (0-indexed) 1523 */ 1524 public XAD getNk132_ContactPersonSAddress(int rep) { 1525 XAD retVal = this.getTypedField(32, rep); 1526 return retVal; 1527 } 1528 1529 /** 1530 * Returns a count of the current number of repetitions of Contact Person’s Address (NK1-32). 1531 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1532 * it will return zero. 1533 */ 1534 public int getNk132_ContactPersonSAddressReps() { 1535 return this.getReps(32); 1536 } 1537 1538 1539 /** 1540 * Inserts a repetition of 1541 * NK1-32: "Contact Person’s Address" at a specific index 1542 * 1543 * @param rep The repetition index (0-indexed) 1544 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1545 */ 1546 public XAD insertContactPersonSAddress(int rep) throws HL7Exception { 1547 return (XAD) super.insertRepetition(32, rep); 1548 } 1549 1550 1551 /** 1552 * Inserts a repetition of 1553 * NK1-32: "Contact Person’s Address" at a specific index 1554 * 1555 * @param rep The repetition index (0-indexed) 1556 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1557 */ 1558 public XAD insertNk132_ContactPersonSAddress(int rep) throws HL7Exception { 1559 return (XAD) super.insertRepetition(32, rep); 1560 } 1561 1562 1563 /** 1564 * Removes a repetition of 1565 * NK1-32: "Contact Person’s Address" at a specific index 1566 * 1567 * @param rep The repetition index (0-indexed) 1568 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1569 */ 1570 public XAD removeContactPersonSAddress(int rep) throws HL7Exception { 1571 return (XAD) super.removeRepetition(32, rep); 1572 } 1573 1574 1575 /** 1576 * Removes a repetition of 1577 * NK1-32: "Contact Person’s Address" at a specific index 1578 * 1579 * @param rep The repetition index (0-indexed) 1580 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1581 */ 1582 public XAD removeNk132_ContactPersonSAddress(int rep) throws HL7Exception { 1583 return (XAD) super.removeRepetition(32, rep); 1584 } 1585 1586 1587 1588 /** 1589 * Returns all repetitions of Associated Party’s Identifiers (NK1-33). 1590 */ 1591 public CX[] getAssociatedPartySIdentifiers() { 1592 CX[] retVal = this.getTypedField(33, new CX[0]); 1593 return retVal; 1594 } 1595 1596 1597 /** 1598 * Returns all repetitions of Associated Party’s Identifiers (NK1-33). 1599 */ 1600 public CX[] getNk133_AssociatedPartySIdentifiers() { 1601 CX[] retVal = this.getTypedField(33, new CX[0]); 1602 return retVal; 1603 } 1604 1605 1606 /** 1607 * Returns a count of the current number of repetitions of Associated Party’s Identifiers (NK1-33). 1608 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1609 * it will return zero. 1610 */ 1611 public int getAssociatedPartySIdentifiersReps() { 1612 return this.getReps(33); 1613 } 1614 1615 1616 /** 1617 * Returns a specific repetition of 1618 * NK1-33: "Associated Party’s Identifiers" - creates it if necessary 1619 * 1620 * @param rep The repetition index (0-indexed) 1621 */ 1622 public CX getAssociatedPartySIdentifiers(int rep) { 1623 CX retVal = this.getTypedField(33, rep); 1624 return retVal; 1625 } 1626 1627 /** 1628 * Returns a specific repetition of 1629 * NK1-33: "Associated Party’s Identifiers" - creates it if necessary 1630 * 1631 * @param rep The repetition index (0-indexed) 1632 */ 1633 public CX getNk133_AssociatedPartySIdentifiers(int rep) { 1634 CX retVal = this.getTypedField(33, rep); 1635 return retVal; 1636 } 1637 1638 /** 1639 * Returns a count of the current number of repetitions of Associated Party’s Identifiers (NK1-33). 1640 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1641 * it will return zero. 1642 */ 1643 public int getNk133_AssociatedPartySIdentifiersReps() { 1644 return this.getReps(33); 1645 } 1646 1647 1648 /** 1649 * Inserts a repetition of 1650 * NK1-33: "Associated Party’s Identifiers" at a specific index 1651 * 1652 * @param rep The repetition index (0-indexed) 1653 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1654 */ 1655 public CX insertAssociatedPartySIdentifiers(int rep) throws HL7Exception { 1656 return (CX) super.insertRepetition(33, rep); 1657 } 1658 1659 1660 /** 1661 * Inserts a repetition of 1662 * NK1-33: "Associated Party’s Identifiers" at a specific index 1663 * 1664 * @param rep The repetition index (0-indexed) 1665 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1666 */ 1667 public CX insertNk133_AssociatedPartySIdentifiers(int rep) throws HL7Exception { 1668 return (CX) super.insertRepetition(33, rep); 1669 } 1670 1671 1672 /** 1673 * Removes a repetition of 1674 * NK1-33: "Associated Party’s Identifiers" at a specific index 1675 * 1676 * @param rep The repetition index (0-indexed) 1677 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1678 */ 1679 public CX removeAssociatedPartySIdentifiers(int rep) throws HL7Exception { 1680 return (CX) super.removeRepetition(33, rep); 1681 } 1682 1683 1684 /** 1685 * Removes a repetition of 1686 * NK1-33: "Associated Party’s Identifiers" at a specific index 1687 * 1688 * @param rep The repetition index (0-indexed) 1689 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1690 */ 1691 public CX removeNk133_AssociatedPartySIdentifiers(int rep) throws HL7Exception { 1692 return (CX) super.removeRepetition(33, rep); 1693 } 1694 1695 1696 1697 1698 /** 1699 * Returns 1700 * NK1-34: "Job Status" - creates it if necessary 1701 */ 1702 public IS getJobStatus() { 1703 IS retVal = this.getTypedField(34, 0); 1704 return retVal; 1705 } 1706 1707 /** 1708 * Returns 1709 * NK1-34: "Job Status" - creates it if necessary 1710 */ 1711 public IS getNk134_JobStatus() { 1712 IS retVal = this.getTypedField(34, 0); 1713 return retVal; 1714 } 1715 1716 1717 1718 /** 1719 * Returns 1720 * NK1-35: "Race" - creates it if necessary 1721 */ 1722 public IS getRace() { 1723 IS retVal = this.getTypedField(35, 0); 1724 return retVal; 1725 } 1726 1727 /** 1728 * Returns 1729 * NK1-35: "Race" - creates it if necessary 1730 */ 1731 public IS getNk135_Race() { 1732 IS retVal = this.getTypedField(35, 0); 1733 return retVal; 1734 } 1735 1736 1737 1738 /** 1739 * Returns 1740 * NK1-36: "Handicap" - creates it if necessary 1741 */ 1742 public IS getHandicap() { 1743 IS retVal = this.getTypedField(36, 0); 1744 return retVal; 1745 } 1746 1747 /** 1748 * Returns 1749 * NK1-36: "Handicap" - creates it if necessary 1750 */ 1751 public IS getNk136_Handicap() { 1752 IS retVal = this.getTypedField(36, 0); 1753 return retVal; 1754 } 1755 1756 1757 1758 /** 1759 * Returns 1760 * NK1-37: "Contact Person Social Security Number" - creates it if necessary 1761 */ 1762 public ST getContactPersonSocialSecurityNumber() { 1763 ST retVal = this.getTypedField(37, 0); 1764 return retVal; 1765 } 1766 1767 /** 1768 * Returns 1769 * NK1-37: "Contact Person Social Security Number" - creates it if necessary 1770 */ 1771 public ST getNk137_ContactPersonSocialSecurityNumber() { 1772 ST retVal = this.getTypedField(37, 0); 1773 return retVal; 1774 } 1775 1776 1777 1778 1779 1780 /** {@inheritDoc} */ 1781 protected Type createNewTypeWithoutReflection(int field) { 1782 switch (field) { 1783 case 0: return new SI(getMessage()); 1784 case 1: return new XPN(getMessage()); 1785 case 2: return new CE(getMessage()); 1786 case 3: return new XAD(getMessage()); 1787 case 4: return new XTN(getMessage()); 1788 case 5: return new XTN(getMessage()); 1789 case 6: return new CE(getMessage()); 1790 case 7: return new DT(getMessage()); 1791 case 8: return new DT(getMessage()); 1792 case 9: return new ST(getMessage()); 1793 case 10: return new JCC(getMessage()); 1794 case 11: return new CX(getMessage()); 1795 case 12: return new XON(getMessage()); 1796 case 13: return new IS(getMessage(), new Integer( 2 )); 1797 case 14: return new IS(getMessage(), new Integer( 1 )); 1798 case 15: return new TS(getMessage()); 1799 case 16: return new IS(getMessage(), new Integer( 223 )); 1800 case 17: return new IS(getMessage(), new Integer( 9 )); 1801 case 18: return new IS(getMessage(), new Integer( 171 )); 1802 case 19: return new CE(getMessage()); 1803 case 20: return new IS(getMessage(), new Integer( 220 )); 1804 case 21: return new CE(getMessage()); 1805 case 22: return new ID(getMessage(), new Integer( 136 )); 1806 case 23: return new IS(getMessage(), new Integer( 231 )); 1807 case 24: return new IS(getMessage(), new Integer( 6 )); 1808 case 25: return new XPN(getMessage()); 1809 case 26: return new CE(getMessage()); 1810 case 27: return new IS(getMessage(), new Integer( 189 )); 1811 case 28: return new CE(getMessage()); 1812 case 29: return new XPN(getMessage()); 1813 case 30: return new XTN(getMessage()); 1814 case 31: return new XAD(getMessage()); 1815 case 32: return new CX(getMessage()); 1816 case 33: return new IS(getMessage(), new Integer( 311 )); 1817 case 34: return new IS(getMessage(), new Integer( 5 )); 1818 case 35: return new IS(getMessage(), new Integer( 310 )); 1819 case 36: return new ST(getMessage()); 1820 default: return null; 1821 } 1822 } 1823 1824 1825} 1826