001package org.hl7.fhir.r5.model; 002 003 004/* 005 * #%L 006 * org.hl7.fhir.r5 007 * %% 008 * Copyright (C) 2014 - 2019 Health Level 7 009 * %% 010 * Licensed under the Apache License, Version 2.0 (the \"License\"); 011 * you may not use this file except in compliance with the License. 012 * You may obtain a copy of the License at 013 * 014 * http://www.apache.org/licenses/LICENSE-2.0 015 * 016 * Unless required by applicable law or agreed to in writing, software 017 * distributed under the License is distributed on an \"AS IS\" BASIS, 018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 019 * See the License for the specific language governing permissions and 020 * limitations under the License. 021 * #L% 022 */ 023 024/* 025 Copyright (c) 2011+, HL7, Inc. 026 All rights reserved. 027 028 Redistribution and use in source and binary forms, with or without modification, \ 029 are permitted provided that the following conditions are met: 030 031 * Redistributions of source code must retain the above copyright notice, this \ 032 list of conditions and the following disclaimer. 033 * Redistributions in binary form must reproduce the above copyright notice, \ 034 this list of conditions and the following disclaimer in the documentation \ 035 and/or other materials provided with the distribution. 036 * Neither the name of HL7 nor the names of its contributors may be used to 037 endorse or promote products derived from this software without specific 038 prior written permission. 039 040 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 041 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 042 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 043 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 044 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 045 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 046 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 047 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 048 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 049 POSSIBILITY OF SUCH DAMAGE. 050 */ 051 052// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent 053 054import java.util.ArrayList; 055import java.util.Date; 056import java.util.List; 057import org.hl7.fhir.utilities.Utilities; 058import org.hl7.fhir.r5.model.Enumerations.*; 059import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 060import org.hl7.fhir.exceptions.FHIRException; 061import org.hl7.fhir.instance.model.api.ICompositeType; 062import ca.uhn.fhir.model.api.annotation.ResourceDef; 063import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 064import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 065import ca.uhn.fhir.model.api.annotation.Child; 066import ca.uhn.fhir.model.api.annotation.ChildOrder; 067import ca.uhn.fhir.model.api.annotation.Description; 068import ca.uhn.fhir.model.api.annotation.Block; 069 070/** 071 * A definition of a condition and information relevant to managing it. 072 */ 073@ResourceDef(name="ConditionDefinition", profile="http://hl7.org/fhir/StructureDefinition/ConditionDefinition") 074public class ConditionDefinition extends MetadataResource { 075 076 public enum ConditionPreconditionType { 077 /** 078 * The observation is very sensitive for the condition, but may also indicate other conditions. 079 */ 080 SENSITIVE, 081 /** 082 * The observation is very specific for this condition, but not particularly sensitive. 083 */ 084 SPECIFIC, 085 /** 086 * added to help the parsers with the generic types 087 */ 088 NULL; 089 public static ConditionPreconditionType fromCode(String codeString) throws FHIRException { 090 if (codeString == null || "".equals(codeString)) 091 return null; 092 if ("sensitive".equals(codeString)) 093 return SENSITIVE; 094 if ("specific".equals(codeString)) 095 return SPECIFIC; 096 if (Configuration.isAcceptInvalidEnums()) 097 return null; 098 else 099 throw new FHIRException("Unknown ConditionPreconditionType code '"+codeString+"'"); 100 } 101 public String toCode() { 102 switch (this) { 103 case SENSITIVE: return "sensitive"; 104 case SPECIFIC: return "specific"; 105 default: return "?"; 106 } 107 } 108 public String getSystem() { 109 switch (this) { 110 case SENSITIVE: return "http://hl7.org/fhir/condition-precondition-type"; 111 case SPECIFIC: return "http://hl7.org/fhir/condition-precondition-type"; 112 default: return "?"; 113 } 114 } 115 public String getDefinition() { 116 switch (this) { 117 case SENSITIVE: return "The observation is very sensitive for the condition, but may also indicate other conditions."; 118 case SPECIFIC: return "The observation is very specific for this condition, but not particularly sensitive."; 119 default: return "?"; 120 } 121 } 122 public String getDisplay() { 123 switch (this) { 124 case SENSITIVE: return "Sensitive"; 125 case SPECIFIC: return "Specific"; 126 default: return "?"; 127 } 128 } 129 } 130 131 public static class ConditionPreconditionTypeEnumFactory implements EnumFactory<ConditionPreconditionType> { 132 public ConditionPreconditionType fromCode(String codeString) throws IllegalArgumentException { 133 if (codeString == null || "".equals(codeString)) 134 if (codeString == null || "".equals(codeString)) 135 return null; 136 if ("sensitive".equals(codeString)) 137 return ConditionPreconditionType.SENSITIVE; 138 if ("specific".equals(codeString)) 139 return ConditionPreconditionType.SPECIFIC; 140 throw new IllegalArgumentException("Unknown ConditionPreconditionType code '"+codeString+"'"); 141 } 142 public Enumeration<ConditionPreconditionType> fromType(Base code) throws FHIRException { 143 if (code == null) 144 return null; 145 if (code.isEmpty()) 146 return new Enumeration<ConditionPreconditionType>(this); 147 String codeString = ((PrimitiveType) code).asStringValue(); 148 if (codeString == null || "".equals(codeString)) 149 return null; 150 if ("sensitive".equals(codeString)) 151 return new Enumeration<ConditionPreconditionType>(this, ConditionPreconditionType.SENSITIVE); 152 if ("specific".equals(codeString)) 153 return new Enumeration<ConditionPreconditionType>(this, ConditionPreconditionType.SPECIFIC); 154 throw new FHIRException("Unknown ConditionPreconditionType code '"+codeString+"'"); 155 } 156 public String toCode(ConditionPreconditionType code) { 157 if (code == ConditionPreconditionType.SENSITIVE) 158 return "sensitive"; 159 if (code == ConditionPreconditionType.SPECIFIC) 160 return "specific"; 161 return "?"; 162 } 163 public String toSystem(ConditionPreconditionType code) { 164 return code.getSystem(); 165 } 166 } 167 168 public enum ConditionQuestionnairePurpose { 169 /** 170 * A pre-admit questionnaire. 171 */ 172 PREADMIT, 173 /** 174 * A questionnaire that helps with diferential diagnosis. 175 */ 176 DIFFDIAGNOSIS, 177 /** 178 * A questionnaire to check on outcomes for the patient. 179 */ 180 OUTCOME, 181 /** 182 * added to help the parsers with the generic types 183 */ 184 NULL; 185 public static ConditionQuestionnairePurpose fromCode(String codeString) throws FHIRException { 186 if (codeString == null || "".equals(codeString)) 187 return null; 188 if ("preadmit".equals(codeString)) 189 return PREADMIT; 190 if ("diff-diagnosis".equals(codeString)) 191 return DIFFDIAGNOSIS; 192 if ("outcome".equals(codeString)) 193 return OUTCOME; 194 if (Configuration.isAcceptInvalidEnums()) 195 return null; 196 else 197 throw new FHIRException("Unknown ConditionQuestionnairePurpose code '"+codeString+"'"); 198 } 199 public String toCode() { 200 switch (this) { 201 case PREADMIT: return "preadmit"; 202 case DIFFDIAGNOSIS: return "diff-diagnosis"; 203 case OUTCOME: return "outcome"; 204 default: return "?"; 205 } 206 } 207 public String getSystem() { 208 switch (this) { 209 case PREADMIT: return "http://hl7.org/fhir/condition-questionnaire-purpose"; 210 case DIFFDIAGNOSIS: return "http://hl7.org/fhir/condition-questionnaire-purpose"; 211 case OUTCOME: return "http://hl7.org/fhir/condition-questionnaire-purpose"; 212 default: return "?"; 213 } 214 } 215 public String getDefinition() { 216 switch (this) { 217 case PREADMIT: return "A pre-admit questionnaire."; 218 case DIFFDIAGNOSIS: return "A questionnaire that helps with diferential diagnosis."; 219 case OUTCOME: return "A questionnaire to check on outcomes for the patient."; 220 default: return "?"; 221 } 222 } 223 public String getDisplay() { 224 switch (this) { 225 case PREADMIT: return "Pre-admit"; 226 case DIFFDIAGNOSIS: return "Diff Diagnosis"; 227 case OUTCOME: return "Outcome"; 228 default: return "?"; 229 } 230 } 231 } 232 233 public static class ConditionQuestionnairePurposeEnumFactory implements EnumFactory<ConditionQuestionnairePurpose> { 234 public ConditionQuestionnairePurpose fromCode(String codeString) throws IllegalArgumentException { 235 if (codeString == null || "".equals(codeString)) 236 if (codeString == null || "".equals(codeString)) 237 return null; 238 if ("preadmit".equals(codeString)) 239 return ConditionQuestionnairePurpose.PREADMIT; 240 if ("diff-diagnosis".equals(codeString)) 241 return ConditionQuestionnairePurpose.DIFFDIAGNOSIS; 242 if ("outcome".equals(codeString)) 243 return ConditionQuestionnairePurpose.OUTCOME; 244 throw new IllegalArgumentException("Unknown ConditionQuestionnairePurpose code '"+codeString+"'"); 245 } 246 public Enumeration<ConditionQuestionnairePurpose> fromType(Base code) throws FHIRException { 247 if (code == null) 248 return null; 249 if (code.isEmpty()) 250 return new Enumeration<ConditionQuestionnairePurpose>(this); 251 String codeString = ((PrimitiveType) code).asStringValue(); 252 if (codeString == null || "".equals(codeString)) 253 return null; 254 if ("preadmit".equals(codeString)) 255 return new Enumeration<ConditionQuestionnairePurpose>(this, ConditionQuestionnairePurpose.PREADMIT); 256 if ("diff-diagnosis".equals(codeString)) 257 return new Enumeration<ConditionQuestionnairePurpose>(this, ConditionQuestionnairePurpose.DIFFDIAGNOSIS); 258 if ("outcome".equals(codeString)) 259 return new Enumeration<ConditionQuestionnairePurpose>(this, ConditionQuestionnairePurpose.OUTCOME); 260 throw new FHIRException("Unknown ConditionQuestionnairePurpose code '"+codeString+"'"); 261 } 262 public String toCode(ConditionQuestionnairePurpose code) { 263 if (code == ConditionQuestionnairePurpose.PREADMIT) 264 return "preadmit"; 265 if (code == ConditionQuestionnairePurpose.DIFFDIAGNOSIS) 266 return "diff-diagnosis"; 267 if (code == ConditionQuestionnairePurpose.OUTCOME) 268 return "outcome"; 269 return "?"; 270 } 271 public String toSystem(ConditionQuestionnairePurpose code) { 272 return code.getSystem(); 273 } 274 } 275 276 @Block() 277 public static class ConditionDefinitionObservationComponent extends BackboneElement implements IBaseBackboneElement { 278 /** 279 * Category that is relevant. 280 */ 281 @Child(name = "category", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false) 282 @Description(shortDefinition="Category that is relevant", formalDefinition="Category that is relevant." ) 283 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/observation-category") 284 protected CodeableConcept category; 285 286 /** 287 * Code for relevant Observation. 288 */ 289 @Child(name = "code", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false) 290 @Description(shortDefinition="Code for relevant Observation", formalDefinition="Code for relevant Observation." ) 291 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/observation-codes") 292 protected CodeableConcept code; 293 294 private static final long serialVersionUID = -1433986479L; 295 296 /** 297 * Constructor 298 */ 299 public ConditionDefinitionObservationComponent() { 300 super(); 301 } 302 303 /** 304 * @return {@link #category} (Category that is relevant.) 305 */ 306 public CodeableConcept getCategory() { 307 if (this.category == null) 308 if (Configuration.errorOnAutoCreate()) 309 throw new Error("Attempt to auto-create ConditionDefinitionObservationComponent.category"); 310 else if (Configuration.doAutoCreate()) 311 this.category = new CodeableConcept(); // cc 312 return this.category; 313 } 314 315 public boolean hasCategory() { 316 return this.category != null && !this.category.isEmpty(); 317 } 318 319 /** 320 * @param value {@link #category} (Category that is relevant.) 321 */ 322 public ConditionDefinitionObservationComponent setCategory(CodeableConcept value) { 323 this.category = value; 324 return this; 325 } 326 327 /** 328 * @return {@link #code} (Code for relevant Observation.) 329 */ 330 public CodeableConcept getCode() { 331 if (this.code == null) 332 if (Configuration.errorOnAutoCreate()) 333 throw new Error("Attempt to auto-create ConditionDefinitionObservationComponent.code"); 334 else if (Configuration.doAutoCreate()) 335 this.code = new CodeableConcept(); // cc 336 return this.code; 337 } 338 339 public boolean hasCode() { 340 return this.code != null && !this.code.isEmpty(); 341 } 342 343 /** 344 * @param value {@link #code} (Code for relevant Observation.) 345 */ 346 public ConditionDefinitionObservationComponent setCode(CodeableConcept value) { 347 this.code = value; 348 return this; 349 } 350 351 protected void listChildren(List<Property> children) { 352 super.listChildren(children); 353 children.add(new Property("category", "CodeableConcept", "Category that is relevant.", 0, 1, category)); 354 children.add(new Property("code", "CodeableConcept", "Code for relevant Observation.", 0, 1, code)); 355 } 356 357 @Override 358 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 359 switch (_hash) { 360 case 50511102: /*category*/ return new Property("category", "CodeableConcept", "Category that is relevant.", 0, 1, category); 361 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Code for relevant Observation.", 0, 1, code); 362 default: return super.getNamedProperty(_hash, _name, _checkValid); 363 } 364 365 } 366 367 @Override 368 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 369 switch (hash) { 370 case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // CodeableConcept 371 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 372 default: return super.getProperty(hash, name, checkValid); 373 } 374 375 } 376 377 @Override 378 public Base setProperty(int hash, String name, Base value) throws FHIRException { 379 switch (hash) { 380 case 50511102: // category 381 this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 382 return value; 383 case 3059181: // code 384 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 385 return value; 386 default: return super.setProperty(hash, name, value); 387 } 388 389 } 390 391 @Override 392 public Base setProperty(String name, Base value) throws FHIRException { 393 if (name.equals("category")) { 394 this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 395 } else if (name.equals("code")) { 396 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 397 } else 398 return super.setProperty(name, value); 399 return value; 400 } 401 402 @Override 403 public Base makeProperty(int hash, String name) throws FHIRException { 404 switch (hash) { 405 case 50511102: return getCategory(); 406 case 3059181: return getCode(); 407 default: return super.makeProperty(hash, name); 408 } 409 410 } 411 412 @Override 413 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 414 switch (hash) { 415 case 50511102: /*category*/ return new String[] {"CodeableConcept"}; 416 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 417 default: return super.getTypesForProperty(hash, name); 418 } 419 420 } 421 422 @Override 423 public Base addChild(String name) throws FHIRException { 424 if (name.equals("category")) { 425 this.category = new CodeableConcept(); 426 return this.category; 427 } 428 else if (name.equals("code")) { 429 this.code = new CodeableConcept(); 430 return this.code; 431 } 432 else 433 return super.addChild(name); 434 } 435 436 public ConditionDefinitionObservationComponent copy() { 437 ConditionDefinitionObservationComponent dst = new ConditionDefinitionObservationComponent(); 438 copyValues(dst); 439 return dst; 440 } 441 442 public void copyValues(ConditionDefinitionObservationComponent dst) { 443 super.copyValues(dst); 444 dst.category = category == null ? null : category.copy(); 445 dst.code = code == null ? null : code.copy(); 446 } 447 448 @Override 449 public boolean equalsDeep(Base other_) { 450 if (!super.equalsDeep(other_)) 451 return false; 452 if (!(other_ instanceof ConditionDefinitionObservationComponent)) 453 return false; 454 ConditionDefinitionObservationComponent o = (ConditionDefinitionObservationComponent) other_; 455 return compareDeep(category, o.category, true) && compareDeep(code, o.code, true); 456 } 457 458 @Override 459 public boolean equalsShallow(Base other_) { 460 if (!super.equalsShallow(other_)) 461 return false; 462 if (!(other_ instanceof ConditionDefinitionObservationComponent)) 463 return false; 464 ConditionDefinitionObservationComponent o = (ConditionDefinitionObservationComponent) other_; 465 return true; 466 } 467 468 public boolean isEmpty() { 469 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, code); 470 } 471 472 public String fhirType() { 473 return "ConditionDefinition.observation"; 474 475 } 476 477 } 478 479 @Block() 480 public static class ConditionDefinitionMedicationComponent extends BackboneElement implements IBaseBackboneElement { 481 /** 482 * Category that is relevant. 483 */ 484 @Child(name = "category", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false) 485 @Description(shortDefinition="Category that is relevant", formalDefinition="Category that is relevant." ) 486 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/medicationrequest-category") 487 protected CodeableConcept category; 488 489 /** 490 * Code for relevant Medication. 491 */ 492 @Child(name = "code", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false) 493 @Description(shortDefinition="Code for relevant Medication", formalDefinition="Code for relevant Medication." ) 494 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/medication-codes") 495 protected CodeableConcept code; 496 497 private static final long serialVersionUID = -1433986479L; 498 499 /** 500 * Constructor 501 */ 502 public ConditionDefinitionMedicationComponent() { 503 super(); 504 } 505 506 /** 507 * @return {@link #category} (Category that is relevant.) 508 */ 509 public CodeableConcept getCategory() { 510 if (this.category == null) 511 if (Configuration.errorOnAutoCreate()) 512 throw new Error("Attempt to auto-create ConditionDefinitionMedicationComponent.category"); 513 else if (Configuration.doAutoCreate()) 514 this.category = new CodeableConcept(); // cc 515 return this.category; 516 } 517 518 public boolean hasCategory() { 519 return this.category != null && !this.category.isEmpty(); 520 } 521 522 /** 523 * @param value {@link #category} (Category that is relevant.) 524 */ 525 public ConditionDefinitionMedicationComponent setCategory(CodeableConcept value) { 526 this.category = value; 527 return this; 528 } 529 530 /** 531 * @return {@link #code} (Code for relevant Medication.) 532 */ 533 public CodeableConcept getCode() { 534 if (this.code == null) 535 if (Configuration.errorOnAutoCreate()) 536 throw new Error("Attempt to auto-create ConditionDefinitionMedicationComponent.code"); 537 else if (Configuration.doAutoCreate()) 538 this.code = new CodeableConcept(); // cc 539 return this.code; 540 } 541 542 public boolean hasCode() { 543 return this.code != null && !this.code.isEmpty(); 544 } 545 546 /** 547 * @param value {@link #code} (Code for relevant Medication.) 548 */ 549 public ConditionDefinitionMedicationComponent setCode(CodeableConcept value) { 550 this.code = value; 551 return this; 552 } 553 554 protected void listChildren(List<Property> children) { 555 super.listChildren(children); 556 children.add(new Property("category", "CodeableConcept", "Category that is relevant.", 0, 1, category)); 557 children.add(new Property("code", "CodeableConcept", "Code for relevant Medication.", 0, 1, code)); 558 } 559 560 @Override 561 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 562 switch (_hash) { 563 case 50511102: /*category*/ return new Property("category", "CodeableConcept", "Category that is relevant.", 0, 1, category); 564 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Code for relevant Medication.", 0, 1, code); 565 default: return super.getNamedProperty(_hash, _name, _checkValid); 566 } 567 568 } 569 570 @Override 571 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 572 switch (hash) { 573 case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // CodeableConcept 574 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 575 default: return super.getProperty(hash, name, checkValid); 576 } 577 578 } 579 580 @Override 581 public Base setProperty(int hash, String name, Base value) throws FHIRException { 582 switch (hash) { 583 case 50511102: // category 584 this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 585 return value; 586 case 3059181: // code 587 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 588 return value; 589 default: return super.setProperty(hash, name, value); 590 } 591 592 } 593 594 @Override 595 public Base setProperty(String name, Base value) throws FHIRException { 596 if (name.equals("category")) { 597 this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 598 } else if (name.equals("code")) { 599 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 600 } else 601 return super.setProperty(name, value); 602 return value; 603 } 604 605 @Override 606 public Base makeProperty(int hash, String name) throws FHIRException { 607 switch (hash) { 608 case 50511102: return getCategory(); 609 case 3059181: return getCode(); 610 default: return super.makeProperty(hash, name); 611 } 612 613 } 614 615 @Override 616 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 617 switch (hash) { 618 case 50511102: /*category*/ return new String[] {"CodeableConcept"}; 619 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 620 default: return super.getTypesForProperty(hash, name); 621 } 622 623 } 624 625 @Override 626 public Base addChild(String name) throws FHIRException { 627 if (name.equals("category")) { 628 this.category = new CodeableConcept(); 629 return this.category; 630 } 631 else if (name.equals("code")) { 632 this.code = new CodeableConcept(); 633 return this.code; 634 } 635 else 636 return super.addChild(name); 637 } 638 639 public ConditionDefinitionMedicationComponent copy() { 640 ConditionDefinitionMedicationComponent dst = new ConditionDefinitionMedicationComponent(); 641 copyValues(dst); 642 return dst; 643 } 644 645 public void copyValues(ConditionDefinitionMedicationComponent dst) { 646 super.copyValues(dst); 647 dst.category = category == null ? null : category.copy(); 648 dst.code = code == null ? null : code.copy(); 649 } 650 651 @Override 652 public boolean equalsDeep(Base other_) { 653 if (!super.equalsDeep(other_)) 654 return false; 655 if (!(other_ instanceof ConditionDefinitionMedicationComponent)) 656 return false; 657 ConditionDefinitionMedicationComponent o = (ConditionDefinitionMedicationComponent) other_; 658 return compareDeep(category, o.category, true) && compareDeep(code, o.code, true); 659 } 660 661 @Override 662 public boolean equalsShallow(Base other_) { 663 if (!super.equalsShallow(other_)) 664 return false; 665 if (!(other_ instanceof ConditionDefinitionMedicationComponent)) 666 return false; 667 ConditionDefinitionMedicationComponent o = (ConditionDefinitionMedicationComponent) other_; 668 return true; 669 } 670 671 public boolean isEmpty() { 672 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, code); 673 } 674 675 public String fhirType() { 676 return "ConditionDefinition.medication"; 677 678 } 679 680 } 681 682 @Block() 683 public static class ConditionDefinitionPreconditionComponent extends BackboneElement implements IBaseBackboneElement { 684 /** 685 * Kind of pre-condition. 686 */ 687 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 688 @Description(shortDefinition="sensitive | specific", formalDefinition="Kind of pre-condition." ) 689 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/condition-precondition-type") 690 protected Enumeration<ConditionPreconditionType> type; 691 692 /** 693 * Code for relevant Observation. 694 */ 695 @Child(name = "code", type = {CodeableConcept.class}, order=2, min=1, max=1, modifier=false, summary=false) 696 @Description(shortDefinition="Code for relevant Observation", formalDefinition="Code for relevant Observation." ) 697 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/observation-codes") 698 protected CodeableConcept code; 699 700 /** 701 * Value of Observation. 702 */ 703 @Child(name = "value", type = {CodeableConcept.class, Quantity.class}, order=3, min=0, max=1, modifier=false, summary=false) 704 @Description(shortDefinition="Value of Observation", formalDefinition="Value of Observation." ) 705 protected DataType value; 706 707 private static final long serialVersionUID = -1210333235L; 708 709 /** 710 * Constructor 711 */ 712 public ConditionDefinitionPreconditionComponent() { 713 super(); 714 } 715 716 /** 717 * Constructor 718 */ 719 public ConditionDefinitionPreconditionComponent(ConditionPreconditionType type, CodeableConcept code) { 720 super(); 721 this.setType(type); 722 this.setCode(code); 723 } 724 725 /** 726 * @return {@link #type} (Kind of pre-condition.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 727 */ 728 public Enumeration<ConditionPreconditionType> getTypeElement() { 729 if (this.type == null) 730 if (Configuration.errorOnAutoCreate()) 731 throw new Error("Attempt to auto-create ConditionDefinitionPreconditionComponent.type"); 732 else if (Configuration.doAutoCreate()) 733 this.type = new Enumeration<ConditionPreconditionType>(new ConditionPreconditionTypeEnumFactory()); // bb 734 return this.type; 735 } 736 737 public boolean hasTypeElement() { 738 return this.type != null && !this.type.isEmpty(); 739 } 740 741 public boolean hasType() { 742 return this.type != null && !this.type.isEmpty(); 743 } 744 745 /** 746 * @param value {@link #type} (Kind of pre-condition.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 747 */ 748 public ConditionDefinitionPreconditionComponent setTypeElement(Enumeration<ConditionPreconditionType> value) { 749 this.type = value; 750 return this; 751 } 752 753 /** 754 * @return Kind of pre-condition. 755 */ 756 public ConditionPreconditionType getType() { 757 return this.type == null ? null : this.type.getValue(); 758 } 759 760 /** 761 * @param value Kind of pre-condition. 762 */ 763 public ConditionDefinitionPreconditionComponent setType(ConditionPreconditionType value) { 764 if (this.type == null) 765 this.type = new Enumeration<ConditionPreconditionType>(new ConditionPreconditionTypeEnumFactory()); 766 this.type.setValue(value); 767 return this; 768 } 769 770 /** 771 * @return {@link #code} (Code for relevant Observation.) 772 */ 773 public CodeableConcept getCode() { 774 if (this.code == null) 775 if (Configuration.errorOnAutoCreate()) 776 throw new Error("Attempt to auto-create ConditionDefinitionPreconditionComponent.code"); 777 else if (Configuration.doAutoCreate()) 778 this.code = new CodeableConcept(); // cc 779 return this.code; 780 } 781 782 public boolean hasCode() { 783 return this.code != null && !this.code.isEmpty(); 784 } 785 786 /** 787 * @param value {@link #code} (Code for relevant Observation.) 788 */ 789 public ConditionDefinitionPreconditionComponent setCode(CodeableConcept value) { 790 this.code = value; 791 return this; 792 } 793 794 /** 795 * @return {@link #value} (Value of Observation.) 796 */ 797 public DataType getValue() { 798 return this.value; 799 } 800 801 /** 802 * @return {@link #value} (Value of Observation.) 803 */ 804 public CodeableConcept getValueCodeableConcept() throws FHIRException { 805 if (this.value == null) 806 this.value = new CodeableConcept(); 807 if (!(this.value instanceof CodeableConcept)) 808 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.value.getClass().getName()+" was encountered"); 809 return (CodeableConcept) this.value; 810 } 811 812 public boolean hasValueCodeableConcept() { 813 return this != null && this.value instanceof CodeableConcept; 814 } 815 816 /** 817 * @return {@link #value} (Value of Observation.) 818 */ 819 public Quantity getValueQuantity() throws FHIRException { 820 if (this.value == null) 821 this.value = new Quantity(); 822 if (!(this.value instanceof Quantity)) 823 throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.value.getClass().getName()+" was encountered"); 824 return (Quantity) this.value; 825 } 826 827 public boolean hasValueQuantity() { 828 return this != null && this.value instanceof Quantity; 829 } 830 831 public boolean hasValue() { 832 return this.value != null && !this.value.isEmpty(); 833 } 834 835 /** 836 * @param value {@link #value} (Value of Observation.) 837 */ 838 public ConditionDefinitionPreconditionComponent setValue(DataType value) { 839 if (value != null && !(value instanceof CodeableConcept || value instanceof Quantity)) 840 throw new Error("Not the right type for ConditionDefinition.precondition.value[x]: "+value.fhirType()); 841 this.value = value; 842 return this; 843 } 844 845 protected void listChildren(List<Property> children) { 846 super.listChildren(children); 847 children.add(new Property("type", "code", "Kind of pre-condition.", 0, 1, type)); 848 children.add(new Property("code", "CodeableConcept", "Code for relevant Observation.", 0, 1, code)); 849 children.add(new Property("value[x]", "CodeableConcept|Quantity", "Value of Observation.", 0, 1, value)); 850 } 851 852 @Override 853 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 854 switch (_hash) { 855 case 3575610: /*type*/ return new Property("type", "code", "Kind of pre-condition.", 0, 1, type); 856 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Code for relevant Observation.", 0, 1, code); 857 case -1410166417: /*value[x]*/ return new Property("value[x]", "CodeableConcept|Quantity", "Value of Observation.", 0, 1, value); 858 case 111972721: /*value*/ return new Property("value[x]", "CodeableConcept|Quantity", "Value of Observation.", 0, 1, value); 859 case 924902896: /*valueCodeableConcept*/ return new Property("value[x]", "CodeableConcept", "Value of Observation.", 0, 1, value); 860 case -2029823716: /*valueQuantity*/ return new Property("value[x]", "Quantity", "Value of Observation.", 0, 1, value); 861 default: return super.getNamedProperty(_hash, _name, _checkValid); 862 } 863 864 } 865 866 @Override 867 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 868 switch (hash) { 869 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<ConditionPreconditionType> 870 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 871 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType 872 default: return super.getProperty(hash, name, checkValid); 873 } 874 875 } 876 877 @Override 878 public Base setProperty(int hash, String name, Base value) throws FHIRException { 879 switch (hash) { 880 case 3575610: // type 881 value = new ConditionPreconditionTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 882 this.type = (Enumeration) value; // Enumeration<ConditionPreconditionType> 883 return value; 884 case 3059181: // code 885 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 886 return value; 887 case 111972721: // value 888 this.value = TypeConvertor.castToType(value); // DataType 889 return value; 890 default: return super.setProperty(hash, name, value); 891 } 892 893 } 894 895 @Override 896 public Base setProperty(String name, Base value) throws FHIRException { 897 if (name.equals("type")) { 898 value = new ConditionPreconditionTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 899 this.type = (Enumeration) value; // Enumeration<ConditionPreconditionType> 900 } else if (name.equals("code")) { 901 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 902 } else if (name.equals("value[x]")) { 903 this.value = TypeConvertor.castToType(value); // DataType 904 } else 905 return super.setProperty(name, value); 906 return value; 907 } 908 909 @Override 910 public Base makeProperty(int hash, String name) throws FHIRException { 911 switch (hash) { 912 case 3575610: return getTypeElement(); 913 case 3059181: return getCode(); 914 case -1410166417: return getValue(); 915 case 111972721: return getValue(); 916 default: return super.makeProperty(hash, name); 917 } 918 919 } 920 921 @Override 922 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 923 switch (hash) { 924 case 3575610: /*type*/ return new String[] {"code"}; 925 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 926 case 111972721: /*value*/ return new String[] {"CodeableConcept", "Quantity"}; 927 default: return super.getTypesForProperty(hash, name); 928 } 929 930 } 931 932 @Override 933 public Base addChild(String name) throws FHIRException { 934 if (name.equals("type")) { 935 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.precondition.type"); 936 } 937 else if (name.equals("code")) { 938 this.code = new CodeableConcept(); 939 return this.code; 940 } 941 else if (name.equals("valueCodeableConcept")) { 942 this.value = new CodeableConcept(); 943 return this.value; 944 } 945 else if (name.equals("valueQuantity")) { 946 this.value = new Quantity(); 947 return this.value; 948 } 949 else 950 return super.addChild(name); 951 } 952 953 public ConditionDefinitionPreconditionComponent copy() { 954 ConditionDefinitionPreconditionComponent dst = new ConditionDefinitionPreconditionComponent(); 955 copyValues(dst); 956 return dst; 957 } 958 959 public void copyValues(ConditionDefinitionPreconditionComponent dst) { 960 super.copyValues(dst); 961 dst.type = type == null ? null : type.copy(); 962 dst.code = code == null ? null : code.copy(); 963 dst.value = value == null ? null : value.copy(); 964 } 965 966 @Override 967 public boolean equalsDeep(Base other_) { 968 if (!super.equalsDeep(other_)) 969 return false; 970 if (!(other_ instanceof ConditionDefinitionPreconditionComponent)) 971 return false; 972 ConditionDefinitionPreconditionComponent o = (ConditionDefinitionPreconditionComponent) other_; 973 return compareDeep(type, o.type, true) && compareDeep(code, o.code, true) && compareDeep(value, o.value, true) 974 ; 975 } 976 977 @Override 978 public boolean equalsShallow(Base other_) { 979 if (!super.equalsShallow(other_)) 980 return false; 981 if (!(other_ instanceof ConditionDefinitionPreconditionComponent)) 982 return false; 983 ConditionDefinitionPreconditionComponent o = (ConditionDefinitionPreconditionComponent) other_; 984 return compareValues(type, o.type, true); 985 } 986 987 public boolean isEmpty() { 988 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, code, value); 989 } 990 991 public String fhirType() { 992 return "ConditionDefinition.precondition"; 993 994 } 995 996 } 997 998 @Block() 999 public static class ConditionDefinitionQuestionnaireComponent extends BackboneElement implements IBaseBackboneElement { 1000 /** 1001 * Use of the questionnaire. 1002 */ 1003 @Child(name = "purpose", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 1004 @Description(shortDefinition="preadmit | diff-diagnosis | outcome", formalDefinition="Use of the questionnaire." ) 1005 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/condition-questionnaire-purpose") 1006 protected Enumeration<ConditionQuestionnairePurpose> purpose; 1007 1008 /** 1009 * Specific Questionnaire. 1010 */ 1011 @Child(name = "reference", type = {Questionnaire.class}, order=2, min=1, max=1, modifier=false, summary=false) 1012 @Description(shortDefinition="Specific Questionnaire", formalDefinition="Specific Questionnaire." ) 1013 protected Reference reference; 1014 1015 private static final long serialVersionUID = -1791379681L; 1016 1017 /** 1018 * Constructor 1019 */ 1020 public ConditionDefinitionQuestionnaireComponent() { 1021 super(); 1022 } 1023 1024 /** 1025 * Constructor 1026 */ 1027 public ConditionDefinitionQuestionnaireComponent(ConditionQuestionnairePurpose purpose, Reference reference) { 1028 super(); 1029 this.setPurpose(purpose); 1030 this.setReference(reference); 1031 } 1032 1033 /** 1034 * @return {@link #purpose} (Use of the questionnaire.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 1035 */ 1036 public Enumeration<ConditionQuestionnairePurpose> getPurposeElement() { 1037 if (this.purpose == null) 1038 if (Configuration.errorOnAutoCreate()) 1039 throw new Error("Attempt to auto-create ConditionDefinitionQuestionnaireComponent.purpose"); 1040 else if (Configuration.doAutoCreate()) 1041 this.purpose = new Enumeration<ConditionQuestionnairePurpose>(new ConditionQuestionnairePurposeEnumFactory()); // bb 1042 return this.purpose; 1043 } 1044 1045 public boolean hasPurposeElement() { 1046 return this.purpose != null && !this.purpose.isEmpty(); 1047 } 1048 1049 public boolean hasPurpose() { 1050 return this.purpose != null && !this.purpose.isEmpty(); 1051 } 1052 1053 /** 1054 * @param value {@link #purpose} (Use of the questionnaire.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 1055 */ 1056 public ConditionDefinitionQuestionnaireComponent setPurposeElement(Enumeration<ConditionQuestionnairePurpose> value) { 1057 this.purpose = value; 1058 return this; 1059 } 1060 1061 /** 1062 * @return Use of the questionnaire. 1063 */ 1064 public ConditionQuestionnairePurpose getPurpose() { 1065 return this.purpose == null ? null : this.purpose.getValue(); 1066 } 1067 1068 /** 1069 * @param value Use of the questionnaire. 1070 */ 1071 public ConditionDefinitionQuestionnaireComponent setPurpose(ConditionQuestionnairePurpose value) { 1072 if (this.purpose == null) 1073 this.purpose = new Enumeration<ConditionQuestionnairePurpose>(new ConditionQuestionnairePurposeEnumFactory()); 1074 this.purpose.setValue(value); 1075 return this; 1076 } 1077 1078 /** 1079 * @return {@link #reference} (Specific Questionnaire.) 1080 */ 1081 public Reference getReference() { 1082 if (this.reference == null) 1083 if (Configuration.errorOnAutoCreate()) 1084 throw new Error("Attempt to auto-create ConditionDefinitionQuestionnaireComponent.reference"); 1085 else if (Configuration.doAutoCreate()) 1086 this.reference = new Reference(); // cc 1087 return this.reference; 1088 } 1089 1090 public boolean hasReference() { 1091 return this.reference != null && !this.reference.isEmpty(); 1092 } 1093 1094 /** 1095 * @param value {@link #reference} (Specific Questionnaire.) 1096 */ 1097 public ConditionDefinitionQuestionnaireComponent setReference(Reference value) { 1098 this.reference = value; 1099 return this; 1100 } 1101 1102 protected void listChildren(List<Property> children) { 1103 super.listChildren(children); 1104 children.add(new Property("purpose", "code", "Use of the questionnaire.", 0, 1, purpose)); 1105 children.add(new Property("reference", "Reference(Questionnaire)", "Specific Questionnaire.", 0, 1, reference)); 1106 } 1107 1108 @Override 1109 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1110 switch (_hash) { 1111 case -220463842: /*purpose*/ return new Property("purpose", "code", "Use of the questionnaire.", 0, 1, purpose); 1112 case -925155509: /*reference*/ return new Property("reference", "Reference(Questionnaire)", "Specific Questionnaire.", 0, 1, reference); 1113 default: return super.getNamedProperty(_hash, _name, _checkValid); 1114 } 1115 1116 } 1117 1118 @Override 1119 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1120 switch (hash) { 1121 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // Enumeration<ConditionQuestionnairePurpose> 1122 case -925155509: /*reference*/ return this.reference == null ? new Base[0] : new Base[] {this.reference}; // Reference 1123 default: return super.getProperty(hash, name, checkValid); 1124 } 1125 1126 } 1127 1128 @Override 1129 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1130 switch (hash) { 1131 case -220463842: // purpose 1132 value = new ConditionQuestionnairePurposeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1133 this.purpose = (Enumeration) value; // Enumeration<ConditionQuestionnairePurpose> 1134 return value; 1135 case -925155509: // reference 1136 this.reference = TypeConvertor.castToReference(value); // Reference 1137 return value; 1138 default: return super.setProperty(hash, name, value); 1139 } 1140 1141 } 1142 1143 @Override 1144 public Base setProperty(String name, Base value) throws FHIRException { 1145 if (name.equals("purpose")) { 1146 value = new ConditionQuestionnairePurposeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1147 this.purpose = (Enumeration) value; // Enumeration<ConditionQuestionnairePurpose> 1148 } else if (name.equals("reference")) { 1149 this.reference = TypeConvertor.castToReference(value); // Reference 1150 } else 1151 return super.setProperty(name, value); 1152 return value; 1153 } 1154 1155 @Override 1156 public Base makeProperty(int hash, String name) throws FHIRException { 1157 switch (hash) { 1158 case -220463842: return getPurposeElement(); 1159 case -925155509: return getReference(); 1160 default: return super.makeProperty(hash, name); 1161 } 1162 1163 } 1164 1165 @Override 1166 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1167 switch (hash) { 1168 case -220463842: /*purpose*/ return new String[] {"code"}; 1169 case -925155509: /*reference*/ return new String[] {"Reference"}; 1170 default: return super.getTypesForProperty(hash, name); 1171 } 1172 1173 } 1174 1175 @Override 1176 public Base addChild(String name) throws FHIRException { 1177 if (name.equals("purpose")) { 1178 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.questionnaire.purpose"); 1179 } 1180 else if (name.equals("reference")) { 1181 this.reference = new Reference(); 1182 return this.reference; 1183 } 1184 else 1185 return super.addChild(name); 1186 } 1187 1188 public ConditionDefinitionQuestionnaireComponent copy() { 1189 ConditionDefinitionQuestionnaireComponent dst = new ConditionDefinitionQuestionnaireComponent(); 1190 copyValues(dst); 1191 return dst; 1192 } 1193 1194 public void copyValues(ConditionDefinitionQuestionnaireComponent dst) { 1195 super.copyValues(dst); 1196 dst.purpose = purpose == null ? null : purpose.copy(); 1197 dst.reference = reference == null ? null : reference.copy(); 1198 } 1199 1200 @Override 1201 public boolean equalsDeep(Base other_) { 1202 if (!super.equalsDeep(other_)) 1203 return false; 1204 if (!(other_ instanceof ConditionDefinitionQuestionnaireComponent)) 1205 return false; 1206 ConditionDefinitionQuestionnaireComponent o = (ConditionDefinitionQuestionnaireComponent) other_; 1207 return compareDeep(purpose, o.purpose, true) && compareDeep(reference, o.reference, true); 1208 } 1209 1210 @Override 1211 public boolean equalsShallow(Base other_) { 1212 if (!super.equalsShallow(other_)) 1213 return false; 1214 if (!(other_ instanceof ConditionDefinitionQuestionnaireComponent)) 1215 return false; 1216 ConditionDefinitionQuestionnaireComponent o = (ConditionDefinitionQuestionnaireComponent) other_; 1217 return compareValues(purpose, o.purpose, true); 1218 } 1219 1220 public boolean isEmpty() { 1221 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, reference); 1222 } 1223 1224 public String fhirType() { 1225 return "ConditionDefinition.questionnaire"; 1226 1227 } 1228 1229 } 1230 1231 @Block() 1232 public static class ConditionDefinitionPlanComponent extends BackboneElement implements IBaseBackboneElement { 1233 /** 1234 * Use for the plan. 1235 */ 1236 @Child(name = "role", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false) 1237 @Description(shortDefinition="Use for the plan", formalDefinition="Use for the plan." ) 1238 protected CodeableConcept role; 1239 1240 /** 1241 * The actual plan. 1242 */ 1243 @Child(name = "reference", type = {PlanDefinition.class}, order=2, min=1, max=1, modifier=false, summary=false) 1244 @Description(shortDefinition="The actual plan", formalDefinition="The actual plan." ) 1245 protected Reference reference; 1246 1247 private static final long serialVersionUID = -1992921787L; 1248 1249 /** 1250 * Constructor 1251 */ 1252 public ConditionDefinitionPlanComponent() { 1253 super(); 1254 } 1255 1256 /** 1257 * Constructor 1258 */ 1259 public ConditionDefinitionPlanComponent(Reference reference) { 1260 super(); 1261 this.setReference(reference); 1262 } 1263 1264 /** 1265 * @return {@link #role} (Use for the plan.) 1266 */ 1267 public CodeableConcept getRole() { 1268 if (this.role == null) 1269 if (Configuration.errorOnAutoCreate()) 1270 throw new Error("Attempt to auto-create ConditionDefinitionPlanComponent.role"); 1271 else if (Configuration.doAutoCreate()) 1272 this.role = new CodeableConcept(); // cc 1273 return this.role; 1274 } 1275 1276 public boolean hasRole() { 1277 return this.role != null && !this.role.isEmpty(); 1278 } 1279 1280 /** 1281 * @param value {@link #role} (Use for the plan.) 1282 */ 1283 public ConditionDefinitionPlanComponent setRole(CodeableConcept value) { 1284 this.role = value; 1285 return this; 1286 } 1287 1288 /** 1289 * @return {@link #reference} (The actual plan.) 1290 */ 1291 public Reference getReference() { 1292 if (this.reference == null) 1293 if (Configuration.errorOnAutoCreate()) 1294 throw new Error("Attempt to auto-create ConditionDefinitionPlanComponent.reference"); 1295 else if (Configuration.doAutoCreate()) 1296 this.reference = new Reference(); // cc 1297 return this.reference; 1298 } 1299 1300 public boolean hasReference() { 1301 return this.reference != null && !this.reference.isEmpty(); 1302 } 1303 1304 /** 1305 * @param value {@link #reference} (The actual plan.) 1306 */ 1307 public ConditionDefinitionPlanComponent setReference(Reference value) { 1308 this.reference = value; 1309 return this; 1310 } 1311 1312 protected void listChildren(List<Property> children) { 1313 super.listChildren(children); 1314 children.add(new Property("role", "CodeableConcept", "Use for the plan.", 0, 1, role)); 1315 children.add(new Property("reference", "Reference(PlanDefinition)", "The actual plan.", 0, 1, reference)); 1316 } 1317 1318 @Override 1319 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1320 switch (_hash) { 1321 case 3506294: /*role*/ return new Property("role", "CodeableConcept", "Use for the plan.", 0, 1, role); 1322 case -925155509: /*reference*/ return new Property("reference", "Reference(PlanDefinition)", "The actual plan.", 0, 1, reference); 1323 default: return super.getNamedProperty(_hash, _name, _checkValid); 1324 } 1325 1326 } 1327 1328 @Override 1329 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1330 switch (hash) { 1331 case 3506294: /*role*/ return this.role == null ? new Base[0] : new Base[] {this.role}; // CodeableConcept 1332 case -925155509: /*reference*/ return this.reference == null ? new Base[0] : new Base[] {this.reference}; // Reference 1333 default: return super.getProperty(hash, name, checkValid); 1334 } 1335 1336 } 1337 1338 @Override 1339 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1340 switch (hash) { 1341 case 3506294: // role 1342 this.role = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1343 return value; 1344 case -925155509: // reference 1345 this.reference = TypeConvertor.castToReference(value); // Reference 1346 return value; 1347 default: return super.setProperty(hash, name, value); 1348 } 1349 1350 } 1351 1352 @Override 1353 public Base setProperty(String name, Base value) throws FHIRException { 1354 if (name.equals("role")) { 1355 this.role = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1356 } else if (name.equals("reference")) { 1357 this.reference = TypeConvertor.castToReference(value); // Reference 1358 } else 1359 return super.setProperty(name, value); 1360 return value; 1361 } 1362 1363 @Override 1364 public Base makeProperty(int hash, String name) throws FHIRException { 1365 switch (hash) { 1366 case 3506294: return getRole(); 1367 case -925155509: return getReference(); 1368 default: return super.makeProperty(hash, name); 1369 } 1370 1371 } 1372 1373 @Override 1374 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1375 switch (hash) { 1376 case 3506294: /*role*/ return new String[] {"CodeableConcept"}; 1377 case -925155509: /*reference*/ return new String[] {"Reference"}; 1378 default: return super.getTypesForProperty(hash, name); 1379 } 1380 1381 } 1382 1383 @Override 1384 public Base addChild(String name) throws FHIRException { 1385 if (name.equals("role")) { 1386 this.role = new CodeableConcept(); 1387 return this.role; 1388 } 1389 else if (name.equals("reference")) { 1390 this.reference = new Reference(); 1391 return this.reference; 1392 } 1393 else 1394 return super.addChild(name); 1395 } 1396 1397 public ConditionDefinitionPlanComponent copy() { 1398 ConditionDefinitionPlanComponent dst = new ConditionDefinitionPlanComponent(); 1399 copyValues(dst); 1400 return dst; 1401 } 1402 1403 public void copyValues(ConditionDefinitionPlanComponent dst) { 1404 super.copyValues(dst); 1405 dst.role = role == null ? null : role.copy(); 1406 dst.reference = reference == null ? null : reference.copy(); 1407 } 1408 1409 @Override 1410 public boolean equalsDeep(Base other_) { 1411 if (!super.equalsDeep(other_)) 1412 return false; 1413 if (!(other_ instanceof ConditionDefinitionPlanComponent)) 1414 return false; 1415 ConditionDefinitionPlanComponent o = (ConditionDefinitionPlanComponent) other_; 1416 return compareDeep(role, o.role, true) && compareDeep(reference, o.reference, true); 1417 } 1418 1419 @Override 1420 public boolean equalsShallow(Base other_) { 1421 if (!super.equalsShallow(other_)) 1422 return false; 1423 if (!(other_ instanceof ConditionDefinitionPlanComponent)) 1424 return false; 1425 ConditionDefinitionPlanComponent o = (ConditionDefinitionPlanComponent) other_; 1426 return true; 1427 } 1428 1429 public boolean isEmpty() { 1430 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(role, reference); 1431 } 1432 1433 public String fhirType() { 1434 return "ConditionDefinition.plan"; 1435 1436 } 1437 1438 } 1439 1440 /** 1441 * An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers. 1442 */ 1443 @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true) 1444 @Description(shortDefinition="Canonical identifier for this condition definition, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers." ) 1445 protected UriType url; 1446 1447 /** 1448 * A formal identifier that is used to identify this condition definition when it is represented in other formats, or referenced in a specification, model, design or an instance. 1449 */ 1450 @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1451 @Description(shortDefinition="Additional identifier for the condition definition", formalDefinition="A formal identifier that is used to identify this condition definition when it is represented in other formats, or referenced in a specification, model, design or an instance." ) 1452 protected List<Identifier> identifier; 1453 1454 /** 1455 * The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 1456 */ 1457 @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1458 @Description(shortDefinition="Business version of the condition definition", formalDefinition="The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence." ) 1459 protected StringType version; 1460 1461 /** 1462 * A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation. 1463 */ 1464 @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1465 @Description(shortDefinition="Name for this condition definition (computer friendly)", formalDefinition="A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation." ) 1466 protected StringType name; 1467 1468 /** 1469 * A short, descriptive, user-friendly title for the condition definition. 1470 */ 1471 @Child(name = "title", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 1472 @Description(shortDefinition="Name for this condition definition (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the condition definition." ) 1473 protected StringType title; 1474 1475 /** 1476 * An explanatory or alternate title for the event definition giving additional information about its content. 1477 */ 1478 @Child(name = "subtitle", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false) 1479 @Description(shortDefinition="Subordinate title of the event definition", formalDefinition="An explanatory or alternate title for the event definition giving additional information about its content." ) 1480 protected StringType subtitle; 1481 1482 /** 1483 * The status of this condition definition. Enables tracking the life-cycle of the content. 1484 */ 1485 @Child(name = "status", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true) 1486 @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this condition definition. Enables tracking the life-cycle of the content." ) 1487 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status") 1488 protected Enumeration<PublicationStatus> status; 1489 1490 /** 1491 * A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 1492 */ 1493 @Child(name = "experimental", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=true) 1494 @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." ) 1495 protected BooleanType experimental; 1496 1497 /** 1498 * The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes. 1499 */ 1500 @Child(name = "date", type = {DateTimeType.class}, order=8, min=0, max=1, modifier=false, summary=true) 1501 @Description(shortDefinition="Date last changed", formalDefinition="The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes." ) 1502 protected DateTimeType date; 1503 1504 /** 1505 * The name of the organization or individual that published the condition definition. 1506 */ 1507 @Child(name = "publisher", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=true) 1508 @Description(shortDefinition="Name of the publisher (organization or individual)", formalDefinition="The name of the organization or individual that published the condition definition." ) 1509 protected StringType publisher; 1510 1511 /** 1512 * Contact details to assist a user in finding and communicating with the publisher. 1513 */ 1514 @Child(name = "contact", type = {ContactDetail.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1515 @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." ) 1516 protected List<ContactDetail> contact; 1517 1518 /** 1519 * A free text natural language description of the condition definition from a consumer's perspective. 1520 */ 1521 @Child(name = "description", type = {MarkdownType.class}, order=11, min=0, max=1, modifier=false, summary=false) 1522 @Description(shortDefinition="Natural language description of the condition definition", formalDefinition="A free text natural language description of the condition definition from a consumer's perspective." ) 1523 protected MarkdownType description; 1524 1525 /** 1526 * The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate condition definition instances. 1527 */ 1528 @Child(name = "useContext", type = {UsageContext.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1529 @Description(shortDefinition="The context that the content is intended to support", formalDefinition="The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate condition definition instances." ) 1530 protected List<UsageContext> useContext; 1531 1532 /** 1533 * A legal or geographic region in which the condition definition is intended to be used. 1534 */ 1535 @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1536 @Description(shortDefinition="Intended jurisdiction for condition definition (if applicable)", formalDefinition="A legal or geographic region in which the condition definition is intended to be used." ) 1537 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction") 1538 protected List<CodeableConcept> jurisdiction; 1539 1540 /** 1541 * Identification of the condition, problem or diagnosis. 1542 */ 1543 @Child(name = "code", type = {CodeableConcept.class}, order=14, min=1, max=1, modifier=false, summary=true) 1544 @Description(shortDefinition="Identification of the condition, problem or diagnosis", formalDefinition="Identification of the condition, problem or diagnosis." ) 1545 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/condition-code") 1546 protected CodeableConcept code; 1547 1548 /** 1549 * A subjective assessment of the severity of the condition as evaluated by the clinician. 1550 */ 1551 @Child(name = "severity", type = {CodeableConcept.class}, order=15, min=0, max=1, modifier=false, summary=true) 1552 @Description(shortDefinition="Subjective severity of condition", formalDefinition="A subjective assessment of the severity of the condition as evaluated by the clinician." ) 1553 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/condition-severity") 1554 protected CodeableConcept severity; 1555 1556 /** 1557 * The anatomical location where this condition manifests itself. 1558 */ 1559 @Child(name = "bodySite", type = {CodeableConcept.class}, order=16, min=0, max=1, modifier=false, summary=true) 1560 @Description(shortDefinition="Anatomical location, if relevant", formalDefinition="The anatomical location where this condition manifests itself." ) 1561 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/body-site") 1562 protected CodeableConcept bodySite; 1563 1564 /** 1565 * Clinical stage or grade of a condition. May include formal severity assessments. 1566 */ 1567 @Child(name = "stage", type = {CodeableConcept.class}, order=17, min=0, max=1, modifier=false, summary=true) 1568 @Description(shortDefinition="Stage/grade, usually assessed formally", formalDefinition="Clinical stage or grade of a condition. May include formal severity assessments." ) 1569 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/condition-stage") 1570 protected CodeableConcept stage; 1571 1572 /** 1573 * Whether Severity is appropriate to collect for this condition. 1574 */ 1575 @Child(name = "hasSeverity", type = {BooleanType.class}, order=18, min=0, max=1, modifier=false, summary=false) 1576 @Description(shortDefinition="Whether Severity is appropriate", formalDefinition="Whether Severity is appropriate to collect for this condition." ) 1577 protected BooleanType hasSeverity; 1578 1579 /** 1580 * Whether bodySite is appropriate to collect for this condition. 1581 */ 1582 @Child(name = "hasBodySite", type = {BooleanType.class}, order=19, min=0, max=1, modifier=false, summary=false) 1583 @Description(shortDefinition="Whether bodySite is appropriate", formalDefinition="Whether bodySite is appropriate to collect for this condition." ) 1584 protected BooleanType hasBodySite; 1585 1586 /** 1587 * Whether stage is appropriate to collect for this condition. 1588 */ 1589 @Child(name = "hasStage", type = {BooleanType.class}, order=20, min=0, max=1, modifier=false, summary=false) 1590 @Description(shortDefinition="Whether stage is appropriate", formalDefinition="Whether stage is appropriate to collect for this condition." ) 1591 protected BooleanType hasStage; 1592 1593 /** 1594 * Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers. 1595 */ 1596 @Child(name = "definition", type = {UriType.class}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1597 @Description(shortDefinition="Formal Definition for the condition", formalDefinition="Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers." ) 1598 protected List<UriType> definition; 1599 1600 /** 1601 * Observations particularly relevant to this condition. 1602 */ 1603 @Child(name = "observation", type = {}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1604 @Description(shortDefinition="Observations particularly relevant to this condition", formalDefinition="Observations particularly relevant to this condition." ) 1605 protected List<ConditionDefinitionObservationComponent> observation; 1606 1607 /** 1608 * Medications particularly relevant for this condition. 1609 */ 1610 @Child(name = "medication", type = {}, order=23, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1611 @Description(shortDefinition="Medications particularly relevant for this condition", formalDefinition="Medications particularly relevant for this condition." ) 1612 protected List<ConditionDefinitionMedicationComponent> medication; 1613 1614 /** 1615 * An observation that suggests that this condition applies. 1616 */ 1617 @Child(name = "precondition", type = {}, order=24, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1618 @Description(shortDefinition="Observation that suggets this condition", formalDefinition="An observation that suggests that this condition applies." ) 1619 protected List<ConditionDefinitionPreconditionComponent> precondition; 1620 1621 /** 1622 * Appropriate team for this condition. 1623 */ 1624 @Child(name = "team", type = {CareTeam.class}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1625 @Description(shortDefinition="Appropriate team for this condition", formalDefinition="Appropriate team for this condition." ) 1626 protected List<Reference> team; 1627 1628 /** 1629 * Questionnaire for this condition. 1630 */ 1631 @Child(name = "questionnaire", type = {}, order=26, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1632 @Description(shortDefinition="Questionnaire for this condition", formalDefinition="Questionnaire for this condition." ) 1633 protected List<ConditionDefinitionQuestionnaireComponent> questionnaire; 1634 1635 /** 1636 * Plan that is appropriate. 1637 */ 1638 @Child(name = "plan", type = {}, order=27, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1639 @Description(shortDefinition="Plan that is appropriate", formalDefinition="Plan that is appropriate." ) 1640 protected List<ConditionDefinitionPlanComponent> plan; 1641 1642 private static final long serialVersionUID = 1798806914L; 1643 1644 /** 1645 * Constructor 1646 */ 1647 public ConditionDefinition() { 1648 super(); 1649 } 1650 1651 /** 1652 * Constructor 1653 */ 1654 public ConditionDefinition(PublicationStatus status, CodeableConcept code) { 1655 super(); 1656 this.setStatus(status); 1657 this.setCode(code); 1658 } 1659 1660 /** 1661 * @return {@link #url} (An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 1662 */ 1663 public UriType getUrlElement() { 1664 if (this.url == null) 1665 if (Configuration.errorOnAutoCreate()) 1666 throw new Error("Attempt to auto-create ConditionDefinition.url"); 1667 else if (Configuration.doAutoCreate()) 1668 this.url = new UriType(); // bb 1669 return this.url; 1670 } 1671 1672 public boolean hasUrlElement() { 1673 return this.url != null && !this.url.isEmpty(); 1674 } 1675 1676 public boolean hasUrl() { 1677 return this.url != null && !this.url.isEmpty(); 1678 } 1679 1680 /** 1681 * @param value {@link #url} (An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 1682 */ 1683 public ConditionDefinition setUrlElement(UriType value) { 1684 this.url = value; 1685 return this; 1686 } 1687 1688 /** 1689 * @return An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers. 1690 */ 1691 public String getUrl() { 1692 return this.url == null ? null : this.url.getValue(); 1693 } 1694 1695 /** 1696 * @param value An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers. 1697 */ 1698 public ConditionDefinition setUrl(String value) { 1699 if (Utilities.noString(value)) 1700 this.url = null; 1701 else { 1702 if (this.url == null) 1703 this.url = new UriType(); 1704 this.url.setValue(value); 1705 } 1706 return this; 1707 } 1708 1709 /** 1710 * @return {@link #identifier} (A formal identifier that is used to identify this condition definition when it is represented in other formats, or referenced in a specification, model, design or an instance.) 1711 */ 1712 public List<Identifier> getIdentifier() { 1713 if (this.identifier == null) 1714 this.identifier = new ArrayList<Identifier>(); 1715 return this.identifier; 1716 } 1717 1718 /** 1719 * @return Returns a reference to <code>this</code> for easy method chaining 1720 */ 1721 public ConditionDefinition setIdentifier(List<Identifier> theIdentifier) { 1722 this.identifier = theIdentifier; 1723 return this; 1724 } 1725 1726 public boolean hasIdentifier() { 1727 if (this.identifier == null) 1728 return false; 1729 for (Identifier item : this.identifier) 1730 if (!item.isEmpty()) 1731 return true; 1732 return false; 1733 } 1734 1735 public Identifier addIdentifier() { //3 1736 Identifier t = new Identifier(); 1737 if (this.identifier == null) 1738 this.identifier = new ArrayList<Identifier>(); 1739 this.identifier.add(t); 1740 return t; 1741 } 1742 1743 public ConditionDefinition addIdentifier(Identifier t) { //3 1744 if (t == null) 1745 return this; 1746 if (this.identifier == null) 1747 this.identifier = new ArrayList<Identifier>(); 1748 this.identifier.add(t); 1749 return this; 1750 } 1751 1752 /** 1753 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3} 1754 */ 1755 public Identifier getIdentifierFirstRep() { 1756 if (getIdentifier().isEmpty()) { 1757 addIdentifier(); 1758 } 1759 return getIdentifier().get(0); 1760 } 1761 1762 /** 1763 * @return {@link #version} (The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1764 */ 1765 public StringType getVersionElement() { 1766 if (this.version == null) 1767 if (Configuration.errorOnAutoCreate()) 1768 throw new Error("Attempt to auto-create ConditionDefinition.version"); 1769 else if (Configuration.doAutoCreate()) 1770 this.version = new StringType(); // bb 1771 return this.version; 1772 } 1773 1774 public boolean hasVersionElement() { 1775 return this.version != null && !this.version.isEmpty(); 1776 } 1777 1778 public boolean hasVersion() { 1779 return this.version != null && !this.version.isEmpty(); 1780 } 1781 1782 /** 1783 * @param value {@link #version} (The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1784 */ 1785 public ConditionDefinition setVersionElement(StringType value) { 1786 this.version = value; 1787 return this; 1788 } 1789 1790 /** 1791 * @return The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 1792 */ 1793 public String getVersion() { 1794 return this.version == null ? null : this.version.getValue(); 1795 } 1796 1797 /** 1798 * @param value The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 1799 */ 1800 public ConditionDefinition setVersion(String value) { 1801 if (Utilities.noString(value)) 1802 this.version = null; 1803 else { 1804 if (this.version == null) 1805 this.version = new StringType(); 1806 this.version.setValue(value); 1807 } 1808 return this; 1809 } 1810 1811 /** 1812 * @return {@link #name} (A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1813 */ 1814 public StringType getNameElement() { 1815 if (this.name == null) 1816 if (Configuration.errorOnAutoCreate()) 1817 throw new Error("Attempt to auto-create ConditionDefinition.name"); 1818 else if (Configuration.doAutoCreate()) 1819 this.name = new StringType(); // bb 1820 return this.name; 1821 } 1822 1823 public boolean hasNameElement() { 1824 return this.name != null && !this.name.isEmpty(); 1825 } 1826 1827 public boolean hasName() { 1828 return this.name != null && !this.name.isEmpty(); 1829 } 1830 1831 /** 1832 * @param value {@link #name} (A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1833 */ 1834 public ConditionDefinition setNameElement(StringType value) { 1835 this.name = value; 1836 return this; 1837 } 1838 1839 /** 1840 * @return A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation. 1841 */ 1842 public String getName() { 1843 return this.name == null ? null : this.name.getValue(); 1844 } 1845 1846 /** 1847 * @param value A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation. 1848 */ 1849 public ConditionDefinition setName(String value) { 1850 if (Utilities.noString(value)) 1851 this.name = null; 1852 else { 1853 if (this.name == null) 1854 this.name = new StringType(); 1855 this.name.setValue(value); 1856 } 1857 return this; 1858 } 1859 1860 /** 1861 * @return {@link #title} (A short, descriptive, user-friendly title for the condition definition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 1862 */ 1863 public StringType getTitleElement() { 1864 if (this.title == null) 1865 if (Configuration.errorOnAutoCreate()) 1866 throw new Error("Attempt to auto-create ConditionDefinition.title"); 1867 else if (Configuration.doAutoCreate()) 1868 this.title = new StringType(); // bb 1869 return this.title; 1870 } 1871 1872 public boolean hasTitleElement() { 1873 return this.title != null && !this.title.isEmpty(); 1874 } 1875 1876 public boolean hasTitle() { 1877 return this.title != null && !this.title.isEmpty(); 1878 } 1879 1880 /** 1881 * @param value {@link #title} (A short, descriptive, user-friendly title for the condition definition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 1882 */ 1883 public ConditionDefinition setTitleElement(StringType value) { 1884 this.title = value; 1885 return this; 1886 } 1887 1888 /** 1889 * @return A short, descriptive, user-friendly title for the condition definition. 1890 */ 1891 public String getTitle() { 1892 return this.title == null ? null : this.title.getValue(); 1893 } 1894 1895 /** 1896 * @param value A short, descriptive, user-friendly title for the condition definition. 1897 */ 1898 public ConditionDefinition setTitle(String value) { 1899 if (Utilities.noString(value)) 1900 this.title = null; 1901 else { 1902 if (this.title == null) 1903 this.title = new StringType(); 1904 this.title.setValue(value); 1905 } 1906 return this; 1907 } 1908 1909 /** 1910 * @return {@link #subtitle} (An explanatory or alternate title for the event definition giving additional information about its content.). This is the underlying object with id, value and extensions. The accessor "getSubtitle" gives direct access to the value 1911 */ 1912 public StringType getSubtitleElement() { 1913 if (this.subtitle == null) 1914 if (Configuration.errorOnAutoCreate()) 1915 throw new Error("Attempt to auto-create ConditionDefinition.subtitle"); 1916 else if (Configuration.doAutoCreate()) 1917 this.subtitle = new StringType(); // bb 1918 return this.subtitle; 1919 } 1920 1921 public boolean hasSubtitleElement() { 1922 return this.subtitle != null && !this.subtitle.isEmpty(); 1923 } 1924 1925 public boolean hasSubtitle() { 1926 return this.subtitle != null && !this.subtitle.isEmpty(); 1927 } 1928 1929 /** 1930 * @param value {@link #subtitle} (An explanatory or alternate title for the event definition giving additional information about its content.). This is the underlying object with id, value and extensions. The accessor "getSubtitle" gives direct access to the value 1931 */ 1932 public ConditionDefinition setSubtitleElement(StringType value) { 1933 this.subtitle = value; 1934 return this; 1935 } 1936 1937 /** 1938 * @return An explanatory or alternate title for the event definition giving additional information about its content. 1939 */ 1940 public String getSubtitle() { 1941 return this.subtitle == null ? null : this.subtitle.getValue(); 1942 } 1943 1944 /** 1945 * @param value An explanatory or alternate title for the event definition giving additional information about its content. 1946 */ 1947 public ConditionDefinition setSubtitle(String value) { 1948 if (Utilities.noString(value)) 1949 this.subtitle = null; 1950 else { 1951 if (this.subtitle == null) 1952 this.subtitle = new StringType(); 1953 this.subtitle.setValue(value); 1954 } 1955 return this; 1956 } 1957 1958 /** 1959 * @return {@link #status} (The status of this condition definition. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1960 */ 1961 public Enumeration<PublicationStatus> getStatusElement() { 1962 if (this.status == null) 1963 if (Configuration.errorOnAutoCreate()) 1964 throw new Error("Attempt to auto-create ConditionDefinition.status"); 1965 else if (Configuration.doAutoCreate()) 1966 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 1967 return this.status; 1968 } 1969 1970 public boolean hasStatusElement() { 1971 return this.status != null && !this.status.isEmpty(); 1972 } 1973 1974 public boolean hasStatus() { 1975 return this.status != null && !this.status.isEmpty(); 1976 } 1977 1978 /** 1979 * @param value {@link #status} (The status of this condition definition. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1980 */ 1981 public ConditionDefinition setStatusElement(Enumeration<PublicationStatus> value) { 1982 this.status = value; 1983 return this; 1984 } 1985 1986 /** 1987 * @return The status of this condition definition. Enables tracking the life-cycle of the content. 1988 */ 1989 public PublicationStatus getStatus() { 1990 return this.status == null ? null : this.status.getValue(); 1991 } 1992 1993 /** 1994 * @param value The status of this condition definition. Enables tracking the life-cycle of the content. 1995 */ 1996 public ConditionDefinition setStatus(PublicationStatus value) { 1997 if (this.status == null) 1998 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 1999 this.status.setValue(value); 2000 return this; 2001 } 2002 2003 /** 2004 * @return {@link #experimental} (A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 2005 */ 2006 public BooleanType getExperimentalElement() { 2007 if (this.experimental == null) 2008 if (Configuration.errorOnAutoCreate()) 2009 throw new Error("Attempt to auto-create ConditionDefinition.experimental"); 2010 else if (Configuration.doAutoCreate()) 2011 this.experimental = new BooleanType(); // bb 2012 return this.experimental; 2013 } 2014 2015 public boolean hasExperimentalElement() { 2016 return this.experimental != null && !this.experimental.isEmpty(); 2017 } 2018 2019 public boolean hasExperimental() { 2020 return this.experimental != null && !this.experimental.isEmpty(); 2021 } 2022 2023 /** 2024 * @param value {@link #experimental} (A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 2025 */ 2026 public ConditionDefinition setExperimentalElement(BooleanType value) { 2027 this.experimental = value; 2028 return this; 2029 } 2030 2031 /** 2032 * @return A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 2033 */ 2034 public boolean getExperimental() { 2035 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 2036 } 2037 2038 /** 2039 * @param value A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 2040 */ 2041 public ConditionDefinition setExperimental(boolean value) { 2042 if (this.experimental == null) 2043 this.experimental = new BooleanType(); 2044 this.experimental.setValue(value); 2045 return this; 2046 } 2047 2048 /** 2049 * @return {@link #date} (The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 2050 */ 2051 public DateTimeType getDateElement() { 2052 if (this.date == null) 2053 if (Configuration.errorOnAutoCreate()) 2054 throw new Error("Attempt to auto-create ConditionDefinition.date"); 2055 else if (Configuration.doAutoCreate()) 2056 this.date = new DateTimeType(); // bb 2057 return this.date; 2058 } 2059 2060 public boolean hasDateElement() { 2061 return this.date != null && !this.date.isEmpty(); 2062 } 2063 2064 public boolean hasDate() { 2065 return this.date != null && !this.date.isEmpty(); 2066 } 2067 2068 /** 2069 * @param value {@link #date} (The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 2070 */ 2071 public ConditionDefinition setDateElement(DateTimeType value) { 2072 this.date = value; 2073 return this; 2074 } 2075 2076 /** 2077 * @return The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes. 2078 */ 2079 public Date getDate() { 2080 return this.date == null ? null : this.date.getValue(); 2081 } 2082 2083 /** 2084 * @param value The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes. 2085 */ 2086 public ConditionDefinition setDate(Date value) { 2087 if (value == null) 2088 this.date = null; 2089 else { 2090 if (this.date == null) 2091 this.date = new DateTimeType(); 2092 this.date.setValue(value); 2093 } 2094 return this; 2095 } 2096 2097 /** 2098 * @return {@link #publisher} (The name of the organization or individual that published the condition definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 2099 */ 2100 public StringType getPublisherElement() { 2101 if (this.publisher == null) 2102 if (Configuration.errorOnAutoCreate()) 2103 throw new Error("Attempt to auto-create ConditionDefinition.publisher"); 2104 else if (Configuration.doAutoCreate()) 2105 this.publisher = new StringType(); // bb 2106 return this.publisher; 2107 } 2108 2109 public boolean hasPublisherElement() { 2110 return this.publisher != null && !this.publisher.isEmpty(); 2111 } 2112 2113 public boolean hasPublisher() { 2114 return this.publisher != null && !this.publisher.isEmpty(); 2115 } 2116 2117 /** 2118 * @param value {@link #publisher} (The name of the organization or individual that published the condition definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 2119 */ 2120 public ConditionDefinition setPublisherElement(StringType value) { 2121 this.publisher = value; 2122 return this; 2123 } 2124 2125 /** 2126 * @return The name of the organization or individual that published the condition definition. 2127 */ 2128 public String getPublisher() { 2129 return this.publisher == null ? null : this.publisher.getValue(); 2130 } 2131 2132 /** 2133 * @param value The name of the organization or individual that published the condition definition. 2134 */ 2135 public ConditionDefinition setPublisher(String value) { 2136 if (Utilities.noString(value)) 2137 this.publisher = null; 2138 else { 2139 if (this.publisher == null) 2140 this.publisher = new StringType(); 2141 this.publisher.setValue(value); 2142 } 2143 return this; 2144 } 2145 2146 /** 2147 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 2148 */ 2149 public List<ContactDetail> getContact() { 2150 if (this.contact == null) 2151 this.contact = new ArrayList<ContactDetail>(); 2152 return this.contact; 2153 } 2154 2155 /** 2156 * @return Returns a reference to <code>this</code> for easy method chaining 2157 */ 2158 public ConditionDefinition setContact(List<ContactDetail> theContact) { 2159 this.contact = theContact; 2160 return this; 2161 } 2162 2163 public boolean hasContact() { 2164 if (this.contact == null) 2165 return false; 2166 for (ContactDetail item : this.contact) 2167 if (!item.isEmpty()) 2168 return true; 2169 return false; 2170 } 2171 2172 public ContactDetail addContact() { //3 2173 ContactDetail t = new ContactDetail(); 2174 if (this.contact == null) 2175 this.contact = new ArrayList<ContactDetail>(); 2176 this.contact.add(t); 2177 return t; 2178 } 2179 2180 public ConditionDefinition addContact(ContactDetail t) { //3 2181 if (t == null) 2182 return this; 2183 if (this.contact == null) 2184 this.contact = new ArrayList<ContactDetail>(); 2185 this.contact.add(t); 2186 return this; 2187 } 2188 2189 /** 2190 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3} 2191 */ 2192 public ContactDetail getContactFirstRep() { 2193 if (getContact().isEmpty()) { 2194 addContact(); 2195 } 2196 return getContact().get(0); 2197 } 2198 2199 /** 2200 * @return {@link #description} (A free text natural language description of the condition definition from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 2201 */ 2202 public MarkdownType getDescriptionElement() { 2203 if (this.description == null) 2204 if (Configuration.errorOnAutoCreate()) 2205 throw new Error("Attempt to auto-create ConditionDefinition.description"); 2206 else if (Configuration.doAutoCreate()) 2207 this.description = new MarkdownType(); // bb 2208 return this.description; 2209 } 2210 2211 public boolean hasDescriptionElement() { 2212 return this.description != null && !this.description.isEmpty(); 2213 } 2214 2215 public boolean hasDescription() { 2216 return this.description != null && !this.description.isEmpty(); 2217 } 2218 2219 /** 2220 * @param value {@link #description} (A free text natural language description of the condition definition from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 2221 */ 2222 public ConditionDefinition setDescriptionElement(MarkdownType value) { 2223 this.description = value; 2224 return this; 2225 } 2226 2227 /** 2228 * @return A free text natural language description of the condition definition from a consumer's perspective. 2229 */ 2230 public String getDescription() { 2231 return this.description == null ? null : this.description.getValue(); 2232 } 2233 2234 /** 2235 * @param value A free text natural language description of the condition definition from a consumer's perspective. 2236 */ 2237 public ConditionDefinition setDescription(String value) { 2238 if (value == null) 2239 this.description = null; 2240 else { 2241 if (this.description == null) 2242 this.description = new MarkdownType(); 2243 this.description.setValue(value); 2244 } 2245 return this; 2246 } 2247 2248 /** 2249 * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate condition definition instances.) 2250 */ 2251 public List<UsageContext> getUseContext() { 2252 if (this.useContext == null) 2253 this.useContext = new ArrayList<UsageContext>(); 2254 return this.useContext; 2255 } 2256 2257 /** 2258 * @return Returns a reference to <code>this</code> for easy method chaining 2259 */ 2260 public ConditionDefinition setUseContext(List<UsageContext> theUseContext) { 2261 this.useContext = theUseContext; 2262 return this; 2263 } 2264 2265 public boolean hasUseContext() { 2266 if (this.useContext == null) 2267 return false; 2268 for (UsageContext item : this.useContext) 2269 if (!item.isEmpty()) 2270 return true; 2271 return false; 2272 } 2273 2274 public UsageContext addUseContext() { //3 2275 UsageContext t = new UsageContext(); 2276 if (this.useContext == null) 2277 this.useContext = new ArrayList<UsageContext>(); 2278 this.useContext.add(t); 2279 return t; 2280 } 2281 2282 public ConditionDefinition addUseContext(UsageContext t) { //3 2283 if (t == null) 2284 return this; 2285 if (this.useContext == null) 2286 this.useContext = new ArrayList<UsageContext>(); 2287 this.useContext.add(t); 2288 return this; 2289 } 2290 2291 /** 2292 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3} 2293 */ 2294 public UsageContext getUseContextFirstRep() { 2295 if (getUseContext().isEmpty()) { 2296 addUseContext(); 2297 } 2298 return getUseContext().get(0); 2299 } 2300 2301 /** 2302 * @return {@link #jurisdiction} (A legal or geographic region in which the condition definition is intended to be used.) 2303 */ 2304 public List<CodeableConcept> getJurisdiction() { 2305 if (this.jurisdiction == null) 2306 this.jurisdiction = new ArrayList<CodeableConcept>(); 2307 return this.jurisdiction; 2308 } 2309 2310 /** 2311 * @return Returns a reference to <code>this</code> for easy method chaining 2312 */ 2313 public ConditionDefinition setJurisdiction(List<CodeableConcept> theJurisdiction) { 2314 this.jurisdiction = theJurisdiction; 2315 return this; 2316 } 2317 2318 public boolean hasJurisdiction() { 2319 if (this.jurisdiction == null) 2320 return false; 2321 for (CodeableConcept item : this.jurisdiction) 2322 if (!item.isEmpty()) 2323 return true; 2324 return false; 2325 } 2326 2327 public CodeableConcept addJurisdiction() { //3 2328 CodeableConcept t = new CodeableConcept(); 2329 if (this.jurisdiction == null) 2330 this.jurisdiction = new ArrayList<CodeableConcept>(); 2331 this.jurisdiction.add(t); 2332 return t; 2333 } 2334 2335 public ConditionDefinition addJurisdiction(CodeableConcept t) { //3 2336 if (t == null) 2337 return this; 2338 if (this.jurisdiction == null) 2339 this.jurisdiction = new ArrayList<CodeableConcept>(); 2340 this.jurisdiction.add(t); 2341 return this; 2342 } 2343 2344 /** 2345 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3} 2346 */ 2347 public CodeableConcept getJurisdictionFirstRep() { 2348 if (getJurisdiction().isEmpty()) { 2349 addJurisdiction(); 2350 } 2351 return getJurisdiction().get(0); 2352 } 2353 2354 /** 2355 * @return {@link #code} (Identification of the condition, problem or diagnosis.) 2356 */ 2357 public CodeableConcept getCode() { 2358 if (this.code == null) 2359 if (Configuration.errorOnAutoCreate()) 2360 throw new Error("Attempt to auto-create ConditionDefinition.code"); 2361 else if (Configuration.doAutoCreate()) 2362 this.code = new CodeableConcept(); // cc 2363 return this.code; 2364 } 2365 2366 public boolean hasCode() { 2367 return this.code != null && !this.code.isEmpty(); 2368 } 2369 2370 /** 2371 * @param value {@link #code} (Identification of the condition, problem or diagnosis.) 2372 */ 2373 public ConditionDefinition setCode(CodeableConcept value) { 2374 this.code = value; 2375 return this; 2376 } 2377 2378 /** 2379 * @return {@link #severity} (A subjective assessment of the severity of the condition as evaluated by the clinician.) 2380 */ 2381 public CodeableConcept getSeverity() { 2382 if (this.severity == null) 2383 if (Configuration.errorOnAutoCreate()) 2384 throw new Error("Attempt to auto-create ConditionDefinition.severity"); 2385 else if (Configuration.doAutoCreate()) 2386 this.severity = new CodeableConcept(); // cc 2387 return this.severity; 2388 } 2389 2390 public boolean hasSeverity() { 2391 return this.severity != null && !this.severity.isEmpty(); 2392 } 2393 2394 /** 2395 * @param value {@link #severity} (A subjective assessment of the severity of the condition as evaluated by the clinician.) 2396 */ 2397 public ConditionDefinition setSeverity(CodeableConcept value) { 2398 this.severity = value; 2399 return this; 2400 } 2401 2402 /** 2403 * @return {@link #bodySite} (The anatomical location where this condition manifests itself.) 2404 */ 2405 public CodeableConcept getBodySite() { 2406 if (this.bodySite == null) 2407 if (Configuration.errorOnAutoCreate()) 2408 throw new Error("Attempt to auto-create ConditionDefinition.bodySite"); 2409 else if (Configuration.doAutoCreate()) 2410 this.bodySite = new CodeableConcept(); // cc 2411 return this.bodySite; 2412 } 2413 2414 public boolean hasBodySite() { 2415 return this.bodySite != null && !this.bodySite.isEmpty(); 2416 } 2417 2418 /** 2419 * @param value {@link #bodySite} (The anatomical location where this condition manifests itself.) 2420 */ 2421 public ConditionDefinition setBodySite(CodeableConcept value) { 2422 this.bodySite = value; 2423 return this; 2424 } 2425 2426 /** 2427 * @return {@link #stage} (Clinical stage or grade of a condition. May include formal severity assessments.) 2428 */ 2429 public CodeableConcept getStage() { 2430 if (this.stage == null) 2431 if (Configuration.errorOnAutoCreate()) 2432 throw new Error("Attempt to auto-create ConditionDefinition.stage"); 2433 else if (Configuration.doAutoCreate()) 2434 this.stage = new CodeableConcept(); // cc 2435 return this.stage; 2436 } 2437 2438 public boolean hasStage() { 2439 return this.stage != null && !this.stage.isEmpty(); 2440 } 2441 2442 /** 2443 * @param value {@link #stage} (Clinical stage or grade of a condition. May include formal severity assessments.) 2444 */ 2445 public ConditionDefinition setStage(CodeableConcept value) { 2446 this.stage = value; 2447 return this; 2448 } 2449 2450 /** 2451 * @return {@link #hasSeverity} (Whether Severity is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasSeverity" gives direct access to the value 2452 */ 2453 public BooleanType getHasSeverityElement() { 2454 if (this.hasSeverity == null) 2455 if (Configuration.errorOnAutoCreate()) 2456 throw new Error("Attempt to auto-create ConditionDefinition.hasSeverity"); 2457 else if (Configuration.doAutoCreate()) 2458 this.hasSeverity = new BooleanType(); // bb 2459 return this.hasSeverity; 2460 } 2461 2462 public boolean hasHasSeverityElement() { 2463 return this.hasSeverity != null && !this.hasSeverity.isEmpty(); 2464 } 2465 2466 public boolean hasHasSeverity() { 2467 return this.hasSeverity != null && !this.hasSeverity.isEmpty(); 2468 } 2469 2470 /** 2471 * @param value {@link #hasSeverity} (Whether Severity is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasSeverity" gives direct access to the value 2472 */ 2473 public ConditionDefinition setHasSeverityElement(BooleanType value) { 2474 this.hasSeverity = value; 2475 return this; 2476 } 2477 2478 /** 2479 * @return Whether Severity is appropriate to collect for this condition. 2480 */ 2481 public boolean getHasSeverity() { 2482 return this.hasSeverity == null || this.hasSeverity.isEmpty() ? false : this.hasSeverity.getValue(); 2483 } 2484 2485 /** 2486 * @param value Whether Severity is appropriate to collect for this condition. 2487 */ 2488 public ConditionDefinition setHasSeverity(boolean value) { 2489 if (this.hasSeverity == null) 2490 this.hasSeverity = new BooleanType(); 2491 this.hasSeverity.setValue(value); 2492 return this; 2493 } 2494 2495 /** 2496 * @return {@link #hasBodySite} (Whether bodySite is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasBodySite" gives direct access to the value 2497 */ 2498 public BooleanType getHasBodySiteElement() { 2499 if (this.hasBodySite == null) 2500 if (Configuration.errorOnAutoCreate()) 2501 throw new Error("Attempt to auto-create ConditionDefinition.hasBodySite"); 2502 else if (Configuration.doAutoCreate()) 2503 this.hasBodySite = new BooleanType(); // bb 2504 return this.hasBodySite; 2505 } 2506 2507 public boolean hasHasBodySiteElement() { 2508 return this.hasBodySite != null && !this.hasBodySite.isEmpty(); 2509 } 2510 2511 public boolean hasHasBodySite() { 2512 return this.hasBodySite != null && !this.hasBodySite.isEmpty(); 2513 } 2514 2515 /** 2516 * @param value {@link #hasBodySite} (Whether bodySite is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasBodySite" gives direct access to the value 2517 */ 2518 public ConditionDefinition setHasBodySiteElement(BooleanType value) { 2519 this.hasBodySite = value; 2520 return this; 2521 } 2522 2523 /** 2524 * @return Whether bodySite is appropriate to collect for this condition. 2525 */ 2526 public boolean getHasBodySite() { 2527 return this.hasBodySite == null || this.hasBodySite.isEmpty() ? false : this.hasBodySite.getValue(); 2528 } 2529 2530 /** 2531 * @param value Whether bodySite is appropriate to collect for this condition. 2532 */ 2533 public ConditionDefinition setHasBodySite(boolean value) { 2534 if (this.hasBodySite == null) 2535 this.hasBodySite = new BooleanType(); 2536 this.hasBodySite.setValue(value); 2537 return this; 2538 } 2539 2540 /** 2541 * @return {@link #hasStage} (Whether stage is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasStage" gives direct access to the value 2542 */ 2543 public BooleanType getHasStageElement() { 2544 if (this.hasStage == null) 2545 if (Configuration.errorOnAutoCreate()) 2546 throw new Error("Attempt to auto-create ConditionDefinition.hasStage"); 2547 else if (Configuration.doAutoCreate()) 2548 this.hasStage = new BooleanType(); // bb 2549 return this.hasStage; 2550 } 2551 2552 public boolean hasHasStageElement() { 2553 return this.hasStage != null && !this.hasStage.isEmpty(); 2554 } 2555 2556 public boolean hasHasStage() { 2557 return this.hasStage != null && !this.hasStage.isEmpty(); 2558 } 2559 2560 /** 2561 * @param value {@link #hasStage} (Whether stage is appropriate to collect for this condition.). This is the underlying object with id, value and extensions. The accessor "getHasStage" gives direct access to the value 2562 */ 2563 public ConditionDefinition setHasStageElement(BooleanType value) { 2564 this.hasStage = value; 2565 return this; 2566 } 2567 2568 /** 2569 * @return Whether stage is appropriate to collect for this condition. 2570 */ 2571 public boolean getHasStage() { 2572 return this.hasStage == null || this.hasStage.isEmpty() ? false : this.hasStage.getValue(); 2573 } 2574 2575 /** 2576 * @param value Whether stage is appropriate to collect for this condition. 2577 */ 2578 public ConditionDefinition setHasStage(boolean value) { 2579 if (this.hasStage == null) 2580 this.hasStage = new BooleanType(); 2581 this.hasStage.setValue(value); 2582 return this; 2583 } 2584 2585 /** 2586 * @return {@link #definition} (Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.) 2587 */ 2588 public List<UriType> getDefinition() { 2589 if (this.definition == null) 2590 this.definition = new ArrayList<UriType>(); 2591 return this.definition; 2592 } 2593 2594 /** 2595 * @return Returns a reference to <code>this</code> for easy method chaining 2596 */ 2597 public ConditionDefinition setDefinition(List<UriType> theDefinition) { 2598 this.definition = theDefinition; 2599 return this; 2600 } 2601 2602 public boolean hasDefinition() { 2603 if (this.definition == null) 2604 return false; 2605 for (UriType item : this.definition) 2606 if (!item.isEmpty()) 2607 return true; 2608 return false; 2609 } 2610 2611 /** 2612 * @return {@link #definition} (Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.) 2613 */ 2614 public UriType addDefinitionElement() {//2 2615 UriType t = new UriType(); 2616 if (this.definition == null) 2617 this.definition = new ArrayList<UriType>(); 2618 this.definition.add(t); 2619 return t; 2620 } 2621 2622 /** 2623 * @param value {@link #definition} (Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.) 2624 */ 2625 public ConditionDefinition addDefinition(String value) { //1 2626 UriType t = new UriType(); 2627 t.setValue(value); 2628 if (this.definition == null) 2629 this.definition = new ArrayList<UriType>(); 2630 this.definition.add(t); 2631 return this; 2632 } 2633 2634 /** 2635 * @param value {@link #definition} (Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.) 2636 */ 2637 public boolean hasDefinition(String value) { 2638 if (this.definition == null) 2639 return false; 2640 for (UriType v : this.definition) 2641 if (v.getValue().equals(value)) // uri 2642 return true; 2643 return false; 2644 } 2645 2646 /** 2647 * @return {@link #observation} (Observations particularly relevant to this condition.) 2648 */ 2649 public List<ConditionDefinitionObservationComponent> getObservation() { 2650 if (this.observation == null) 2651 this.observation = new ArrayList<ConditionDefinitionObservationComponent>(); 2652 return this.observation; 2653 } 2654 2655 /** 2656 * @return Returns a reference to <code>this</code> for easy method chaining 2657 */ 2658 public ConditionDefinition setObservation(List<ConditionDefinitionObservationComponent> theObservation) { 2659 this.observation = theObservation; 2660 return this; 2661 } 2662 2663 public boolean hasObservation() { 2664 if (this.observation == null) 2665 return false; 2666 for (ConditionDefinitionObservationComponent item : this.observation) 2667 if (!item.isEmpty()) 2668 return true; 2669 return false; 2670 } 2671 2672 public ConditionDefinitionObservationComponent addObservation() { //3 2673 ConditionDefinitionObservationComponent t = new ConditionDefinitionObservationComponent(); 2674 if (this.observation == null) 2675 this.observation = new ArrayList<ConditionDefinitionObservationComponent>(); 2676 this.observation.add(t); 2677 return t; 2678 } 2679 2680 public ConditionDefinition addObservation(ConditionDefinitionObservationComponent t) { //3 2681 if (t == null) 2682 return this; 2683 if (this.observation == null) 2684 this.observation = new ArrayList<ConditionDefinitionObservationComponent>(); 2685 this.observation.add(t); 2686 return this; 2687 } 2688 2689 /** 2690 * @return The first repetition of repeating field {@link #observation}, creating it if it does not already exist {3} 2691 */ 2692 public ConditionDefinitionObservationComponent getObservationFirstRep() { 2693 if (getObservation().isEmpty()) { 2694 addObservation(); 2695 } 2696 return getObservation().get(0); 2697 } 2698 2699 /** 2700 * @return {@link #medication} (Medications particularly relevant for this condition.) 2701 */ 2702 public List<ConditionDefinitionMedicationComponent> getMedication() { 2703 if (this.medication == null) 2704 this.medication = new ArrayList<ConditionDefinitionMedicationComponent>(); 2705 return this.medication; 2706 } 2707 2708 /** 2709 * @return Returns a reference to <code>this</code> for easy method chaining 2710 */ 2711 public ConditionDefinition setMedication(List<ConditionDefinitionMedicationComponent> theMedication) { 2712 this.medication = theMedication; 2713 return this; 2714 } 2715 2716 public boolean hasMedication() { 2717 if (this.medication == null) 2718 return false; 2719 for (ConditionDefinitionMedicationComponent item : this.medication) 2720 if (!item.isEmpty()) 2721 return true; 2722 return false; 2723 } 2724 2725 public ConditionDefinitionMedicationComponent addMedication() { //3 2726 ConditionDefinitionMedicationComponent t = new ConditionDefinitionMedicationComponent(); 2727 if (this.medication == null) 2728 this.medication = new ArrayList<ConditionDefinitionMedicationComponent>(); 2729 this.medication.add(t); 2730 return t; 2731 } 2732 2733 public ConditionDefinition addMedication(ConditionDefinitionMedicationComponent t) { //3 2734 if (t == null) 2735 return this; 2736 if (this.medication == null) 2737 this.medication = new ArrayList<ConditionDefinitionMedicationComponent>(); 2738 this.medication.add(t); 2739 return this; 2740 } 2741 2742 /** 2743 * @return The first repetition of repeating field {@link #medication}, creating it if it does not already exist {3} 2744 */ 2745 public ConditionDefinitionMedicationComponent getMedicationFirstRep() { 2746 if (getMedication().isEmpty()) { 2747 addMedication(); 2748 } 2749 return getMedication().get(0); 2750 } 2751 2752 /** 2753 * @return {@link #precondition} (An observation that suggests that this condition applies.) 2754 */ 2755 public List<ConditionDefinitionPreconditionComponent> getPrecondition() { 2756 if (this.precondition == null) 2757 this.precondition = new ArrayList<ConditionDefinitionPreconditionComponent>(); 2758 return this.precondition; 2759 } 2760 2761 /** 2762 * @return Returns a reference to <code>this</code> for easy method chaining 2763 */ 2764 public ConditionDefinition setPrecondition(List<ConditionDefinitionPreconditionComponent> thePrecondition) { 2765 this.precondition = thePrecondition; 2766 return this; 2767 } 2768 2769 public boolean hasPrecondition() { 2770 if (this.precondition == null) 2771 return false; 2772 for (ConditionDefinitionPreconditionComponent item : this.precondition) 2773 if (!item.isEmpty()) 2774 return true; 2775 return false; 2776 } 2777 2778 public ConditionDefinitionPreconditionComponent addPrecondition() { //3 2779 ConditionDefinitionPreconditionComponent t = new ConditionDefinitionPreconditionComponent(); 2780 if (this.precondition == null) 2781 this.precondition = new ArrayList<ConditionDefinitionPreconditionComponent>(); 2782 this.precondition.add(t); 2783 return t; 2784 } 2785 2786 public ConditionDefinition addPrecondition(ConditionDefinitionPreconditionComponent t) { //3 2787 if (t == null) 2788 return this; 2789 if (this.precondition == null) 2790 this.precondition = new ArrayList<ConditionDefinitionPreconditionComponent>(); 2791 this.precondition.add(t); 2792 return this; 2793 } 2794 2795 /** 2796 * @return The first repetition of repeating field {@link #precondition}, creating it if it does not already exist {3} 2797 */ 2798 public ConditionDefinitionPreconditionComponent getPreconditionFirstRep() { 2799 if (getPrecondition().isEmpty()) { 2800 addPrecondition(); 2801 } 2802 return getPrecondition().get(0); 2803 } 2804 2805 /** 2806 * @return {@link #team} (Appropriate team for this condition.) 2807 */ 2808 public List<Reference> getTeam() { 2809 if (this.team == null) 2810 this.team = new ArrayList<Reference>(); 2811 return this.team; 2812 } 2813 2814 /** 2815 * @return Returns a reference to <code>this</code> for easy method chaining 2816 */ 2817 public ConditionDefinition setTeam(List<Reference> theTeam) { 2818 this.team = theTeam; 2819 return this; 2820 } 2821 2822 public boolean hasTeam() { 2823 if (this.team == null) 2824 return false; 2825 for (Reference item : this.team) 2826 if (!item.isEmpty()) 2827 return true; 2828 return false; 2829 } 2830 2831 public Reference addTeam() { //3 2832 Reference t = new Reference(); 2833 if (this.team == null) 2834 this.team = new ArrayList<Reference>(); 2835 this.team.add(t); 2836 return t; 2837 } 2838 2839 public ConditionDefinition addTeam(Reference t) { //3 2840 if (t == null) 2841 return this; 2842 if (this.team == null) 2843 this.team = new ArrayList<Reference>(); 2844 this.team.add(t); 2845 return this; 2846 } 2847 2848 /** 2849 * @return The first repetition of repeating field {@link #team}, creating it if it does not already exist {3} 2850 */ 2851 public Reference getTeamFirstRep() { 2852 if (getTeam().isEmpty()) { 2853 addTeam(); 2854 } 2855 return getTeam().get(0); 2856 } 2857 2858 /** 2859 * @return {@link #questionnaire} (Questionnaire for this condition.) 2860 */ 2861 public List<ConditionDefinitionQuestionnaireComponent> getQuestionnaire() { 2862 if (this.questionnaire == null) 2863 this.questionnaire = new ArrayList<ConditionDefinitionQuestionnaireComponent>(); 2864 return this.questionnaire; 2865 } 2866 2867 /** 2868 * @return Returns a reference to <code>this</code> for easy method chaining 2869 */ 2870 public ConditionDefinition setQuestionnaire(List<ConditionDefinitionQuestionnaireComponent> theQuestionnaire) { 2871 this.questionnaire = theQuestionnaire; 2872 return this; 2873 } 2874 2875 public boolean hasQuestionnaire() { 2876 if (this.questionnaire == null) 2877 return false; 2878 for (ConditionDefinitionQuestionnaireComponent item : this.questionnaire) 2879 if (!item.isEmpty()) 2880 return true; 2881 return false; 2882 } 2883 2884 public ConditionDefinitionQuestionnaireComponent addQuestionnaire() { //3 2885 ConditionDefinitionQuestionnaireComponent t = new ConditionDefinitionQuestionnaireComponent(); 2886 if (this.questionnaire == null) 2887 this.questionnaire = new ArrayList<ConditionDefinitionQuestionnaireComponent>(); 2888 this.questionnaire.add(t); 2889 return t; 2890 } 2891 2892 public ConditionDefinition addQuestionnaire(ConditionDefinitionQuestionnaireComponent t) { //3 2893 if (t == null) 2894 return this; 2895 if (this.questionnaire == null) 2896 this.questionnaire = new ArrayList<ConditionDefinitionQuestionnaireComponent>(); 2897 this.questionnaire.add(t); 2898 return this; 2899 } 2900 2901 /** 2902 * @return The first repetition of repeating field {@link #questionnaire}, creating it if it does not already exist {3} 2903 */ 2904 public ConditionDefinitionQuestionnaireComponent getQuestionnaireFirstRep() { 2905 if (getQuestionnaire().isEmpty()) { 2906 addQuestionnaire(); 2907 } 2908 return getQuestionnaire().get(0); 2909 } 2910 2911 /** 2912 * @return {@link #plan} (Plan that is appropriate.) 2913 */ 2914 public List<ConditionDefinitionPlanComponent> getPlan() { 2915 if (this.plan == null) 2916 this.plan = new ArrayList<ConditionDefinitionPlanComponent>(); 2917 return this.plan; 2918 } 2919 2920 /** 2921 * @return Returns a reference to <code>this</code> for easy method chaining 2922 */ 2923 public ConditionDefinition setPlan(List<ConditionDefinitionPlanComponent> thePlan) { 2924 this.plan = thePlan; 2925 return this; 2926 } 2927 2928 public boolean hasPlan() { 2929 if (this.plan == null) 2930 return false; 2931 for (ConditionDefinitionPlanComponent item : this.plan) 2932 if (!item.isEmpty()) 2933 return true; 2934 return false; 2935 } 2936 2937 public ConditionDefinitionPlanComponent addPlan() { //3 2938 ConditionDefinitionPlanComponent t = new ConditionDefinitionPlanComponent(); 2939 if (this.plan == null) 2940 this.plan = new ArrayList<ConditionDefinitionPlanComponent>(); 2941 this.plan.add(t); 2942 return t; 2943 } 2944 2945 public ConditionDefinition addPlan(ConditionDefinitionPlanComponent t) { //3 2946 if (t == null) 2947 return this; 2948 if (this.plan == null) 2949 this.plan = new ArrayList<ConditionDefinitionPlanComponent>(); 2950 this.plan.add(t); 2951 return this; 2952 } 2953 2954 /** 2955 * @return The first repetition of repeating field {@link #plan}, creating it if it does not already exist {3} 2956 */ 2957 public ConditionDefinitionPlanComponent getPlanFirstRep() { 2958 if (getPlan().isEmpty()) { 2959 addPlan(); 2960 } 2961 return getPlan().get(0); 2962 } 2963 2964 /** 2965 * not supported on this implementation 2966 */ 2967 @Override 2968 public int getPurposeMax() { 2969 return 0; 2970 } 2971 /** 2972 * @return {@link #purpose} (Explanation of why this condition definition is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 2973 */ 2974 public MarkdownType getPurposeElement() { 2975 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"purpose\""); 2976 } 2977 2978 public boolean hasPurposeElement() { 2979 return false; 2980 } 2981 public boolean hasPurpose() { 2982 return false; 2983 } 2984 2985 /** 2986 * @param value {@link #purpose} (Explanation of why this condition definition is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 2987 */ 2988 public ConditionDefinition setPurposeElement(MarkdownType value) { 2989 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"purpose\""); 2990 } 2991 public String getPurpose() { 2992 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"purpose\""); 2993 } 2994 /** 2995 * @param value Explanation of why this condition definition is needed and why it has been designed as it has. 2996 */ 2997 public ConditionDefinition setPurpose(String value) { 2998 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"purpose\""); 2999 } 3000 /** 3001 * not supported on this implementation 3002 */ 3003 @Override 3004 public int getCopyrightMax() { 3005 return 0; 3006 } 3007 /** 3008 * @return {@link #copyright} (A copyright statement relating to the condition definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the condition definition.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 3009 */ 3010 public MarkdownType getCopyrightElement() { 3011 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"copyright\""); 3012 } 3013 3014 public boolean hasCopyrightElement() { 3015 return false; 3016 } 3017 public boolean hasCopyright() { 3018 return false; 3019 } 3020 3021 /** 3022 * @param value {@link #copyright} (A copyright statement relating to the condition definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the condition definition.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 3023 */ 3024 public ConditionDefinition setCopyrightElement(MarkdownType value) { 3025 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"copyright\""); 3026 } 3027 public String getCopyright() { 3028 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"copyright\""); 3029 } 3030 /** 3031 * @param value A copyright statement relating to the condition definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the condition definition. 3032 */ 3033 public ConditionDefinition setCopyright(String value) { 3034 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"copyright\""); 3035 } 3036 /** 3037 * not supported on this implementation 3038 */ 3039 @Override 3040 public int getApprovalDateMax() { 3041 return 0; 3042 } 3043 /** 3044 * @return {@link #approvalDate} (The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.). This is the underlying object with id, value and extensions. The accessor "getApprovalDate" gives direct access to the value 3045 */ 3046 public DateType getApprovalDateElement() { 3047 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"approvalDate\""); 3048 } 3049 3050 public boolean hasApprovalDateElement() { 3051 return false; 3052 } 3053 public boolean hasApprovalDate() { 3054 return false; 3055 } 3056 3057 /** 3058 * @param value {@link #approvalDate} (The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.). This is the underlying object with id, value and extensions. The accessor "getApprovalDate" gives direct access to the value 3059 */ 3060 public ConditionDefinition setApprovalDateElement(DateType value) { 3061 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"approvalDate\""); 3062 } 3063 public Date getApprovalDate() { 3064 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"approvalDate\""); 3065 } 3066 /** 3067 * @param value The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage. 3068 */ 3069 public ConditionDefinition setApprovalDate(Date value) { 3070 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"approvalDate\""); 3071 } 3072 /** 3073 * not supported on this implementation 3074 */ 3075 @Override 3076 public int getLastReviewDateMax() { 3077 return 0; 3078 } 3079 /** 3080 * @return {@link #lastReviewDate} (The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.). This is the underlying object with id, value and extensions. The accessor "getLastReviewDate" gives direct access to the value 3081 */ 3082 public DateType getLastReviewDateElement() { 3083 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"lastReviewDate\""); 3084 } 3085 3086 public boolean hasLastReviewDateElement() { 3087 return false; 3088 } 3089 public boolean hasLastReviewDate() { 3090 return false; 3091 } 3092 3093 /** 3094 * @param value {@link #lastReviewDate} (The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date.). This is the underlying object with id, value and extensions. The accessor "getLastReviewDate" gives direct access to the value 3095 */ 3096 public ConditionDefinition setLastReviewDateElement(DateType value) { 3097 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"lastReviewDate\""); 3098 } 3099 public Date getLastReviewDate() { 3100 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"lastReviewDate\""); 3101 } 3102 /** 3103 * @param value The date on which the resource content was last reviewed. Review happens periodically after approval but does not change the original approval date. 3104 */ 3105 public ConditionDefinition setLastReviewDate(Date value) { 3106 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"lastReviewDate\""); 3107 } 3108 /** 3109 * not supported on this implementation 3110 */ 3111 @Override 3112 public int getEffectivePeriodMax() { 3113 return 0; 3114 } 3115 /** 3116 * @return {@link #effectivePeriod} (The period during which the condition definition content was or is planned to be in active use.) 3117 */ 3118 public Period getEffectivePeriod() { 3119 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"effectivePeriod\""); 3120 } 3121 public boolean hasEffectivePeriod() { 3122 return false; 3123 } 3124 /** 3125 * @param value {@link #effectivePeriod} (The period during which the condition definition content was or is planned to be in active use.) 3126 */ 3127 public ConditionDefinition setEffectivePeriod(Period value) { 3128 throw new Error("The resource type \"ConditionDefinition\" does not implement the property \"effectivePeriod\""); 3129 } 3130 3131 protected void listChildren(List<Property> children) { 3132 super.listChildren(children); 3133 children.add(new Property("url", "uri", "An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers.", 0, 1, url)); 3134 children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this condition definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier)); 3135 children.add(new Property("version", "string", "The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version)); 3136 children.add(new Property("name", "string", "A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 3137 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the condition definition.", 0, 1, title)); 3138 children.add(new Property("subtitle", "string", "An explanatory or alternate title for the event definition giving additional information about its content.", 0, 1, subtitle)); 3139 children.add(new Property("status", "code", "The status of this condition definition. Enables tracking the life-cycle of the content.", 0, 1, status)); 3140 children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental)); 3141 children.add(new Property("date", "dateTime", "The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes.", 0, 1, date)); 3142 children.add(new Property("publisher", "string", "The name of the organization or individual that published the condition definition.", 0, 1, publisher)); 3143 children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact)); 3144 children.add(new Property("description", "markdown", "A free text natural language description of the condition definition from a consumer's perspective.", 0, 1, description)); 3145 children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate condition definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 3146 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the condition definition is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 3147 children.add(new Property("code", "CodeableConcept", "Identification of the condition, problem or diagnosis.", 0, 1, code)); 3148 children.add(new Property("severity", "CodeableConcept", "A subjective assessment of the severity of the condition as evaluated by the clinician.", 0, 1, severity)); 3149 children.add(new Property("bodySite", "CodeableConcept", "The anatomical location where this condition manifests itself.", 0, 1, bodySite)); 3150 children.add(new Property("stage", "CodeableConcept", "Clinical stage or grade of a condition. May include formal severity assessments.", 0, 1, stage)); 3151 children.add(new Property("hasSeverity", "boolean", "Whether Severity is appropriate to collect for this condition.", 0, 1, hasSeverity)); 3152 children.add(new Property("hasBodySite", "boolean", "Whether bodySite is appropriate to collect for this condition.", 0, 1, hasBodySite)); 3153 children.add(new Property("hasStage", "boolean", "Whether stage is appropriate to collect for this condition.", 0, 1, hasStage)); 3154 children.add(new Property("definition", "uri", "Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.", 0, java.lang.Integer.MAX_VALUE, definition)); 3155 children.add(new Property("observation", "", "Observations particularly relevant to this condition.", 0, java.lang.Integer.MAX_VALUE, observation)); 3156 children.add(new Property("medication", "", "Medications particularly relevant for this condition.", 0, java.lang.Integer.MAX_VALUE, medication)); 3157 children.add(new Property("precondition", "", "An observation that suggests that this condition applies.", 0, java.lang.Integer.MAX_VALUE, precondition)); 3158 children.add(new Property("team", "Reference(CareTeam)", "Appropriate team for this condition.", 0, java.lang.Integer.MAX_VALUE, team)); 3159 children.add(new Property("questionnaire", "", "Questionnaire for this condition.", 0, java.lang.Integer.MAX_VALUE, questionnaire)); 3160 children.add(new Property("plan", "", "Plan that is appropriate.", 0, java.lang.Integer.MAX_VALUE, plan)); 3161 } 3162 3163 @Override 3164 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3165 switch (_hash) { 3166 case 116079: /*url*/ return new Property("url", "uri", "An absolute URI that is used to identify this condition definition when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this condition definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the condition definition is stored on different servers.", 0, 1, url); 3167 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "A formal identifier that is used to identify this condition definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier); 3168 case 351608024: /*version*/ return new Property("version", "string", "The identifier that is used to identify this version of the condition definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the condition definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version); 3169 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the condition definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 3170 case 110371416: /*title*/ return new Property("title", "string", "A short, descriptive, user-friendly title for the condition definition.", 0, 1, title); 3171 case -2060497896: /*subtitle*/ return new Property("subtitle", "string", "An explanatory or alternate title for the event definition giving additional information about its content.", 0, 1, subtitle); 3172 case -892481550: /*status*/ return new Property("status", "code", "The status of this condition definition. Enables tracking the life-cycle of the content.", 0, 1, status); 3173 case -404562712: /*experimental*/ return new Property("experimental", "boolean", "A Boolean value to indicate that this condition definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental); 3174 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the condition definition was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the condition definition changes.", 0, 1, date); 3175 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the organization or individual that published the condition definition.", 0, 1, publisher); 3176 case 951526432: /*contact*/ return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact); 3177 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the condition definition from a consumer's perspective.", 0, 1, description); 3178 case -669707736: /*useContext*/ return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate condition definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 3179 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the condition definition is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 3180 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Identification of the condition, problem or diagnosis.", 0, 1, code); 3181 case 1478300413: /*severity*/ return new Property("severity", "CodeableConcept", "A subjective assessment of the severity of the condition as evaluated by the clinician.", 0, 1, severity); 3182 case 1702620169: /*bodySite*/ return new Property("bodySite", "CodeableConcept", "The anatomical location where this condition manifests itself.", 0, 1, bodySite); 3183 case 109757182: /*stage*/ return new Property("stage", "CodeableConcept", "Clinical stage or grade of a condition. May include formal severity assessments.", 0, 1, stage); 3184 case 57790391: /*hasSeverity*/ return new Property("hasSeverity", "boolean", "Whether Severity is appropriate to collect for this condition.", 0, 1, hasSeverity); 3185 case 282110147: /*hasBodySite*/ return new Property("hasBodySite", "boolean", "Whether bodySite is appropriate to collect for this condition.", 0, 1, hasBodySite); 3186 case 129749124: /*hasStage*/ return new Property("hasStage", "boolean", "Whether stage is appropriate to collect for this condition.", 0, 1, hasStage); 3187 case -1014418093: /*definition*/ return new Property("definition", "uri", "Formal definitions of the condition. These may be references to ontologies, published clinical protocols or research papers.", 0, java.lang.Integer.MAX_VALUE, definition); 3188 case 122345516: /*observation*/ return new Property("observation", "", "Observations particularly relevant to this condition.", 0, java.lang.Integer.MAX_VALUE, observation); 3189 case 1998965455: /*medication*/ return new Property("medication", "", "Medications particularly relevant for this condition.", 0, java.lang.Integer.MAX_VALUE, medication); 3190 case -650968616: /*precondition*/ return new Property("precondition", "", "An observation that suggests that this condition applies.", 0, java.lang.Integer.MAX_VALUE, precondition); 3191 case 3555933: /*team*/ return new Property("team", "Reference(CareTeam)", "Appropriate team for this condition.", 0, java.lang.Integer.MAX_VALUE, team); 3192 case -1017049693: /*questionnaire*/ return new Property("questionnaire", "", "Questionnaire for this condition.", 0, java.lang.Integer.MAX_VALUE, questionnaire); 3193 case 3443497: /*plan*/ return new Property("plan", "", "Plan that is appropriate.", 0, java.lang.Integer.MAX_VALUE, plan); 3194 default: return super.getNamedProperty(_hash, _name, _checkValid); 3195 } 3196 3197 } 3198 3199 @Override 3200 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3201 switch (hash) { 3202 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 3203 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 3204 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 3205 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 3206 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 3207 case -2060497896: /*subtitle*/ return this.subtitle == null ? new Base[0] : new Base[] {this.subtitle}; // StringType 3208 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 3209 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 3210 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 3211 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 3212 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 3213 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 3214 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 3215 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 3216 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 3217 case 1478300413: /*severity*/ return this.severity == null ? new Base[0] : new Base[] {this.severity}; // CodeableConcept 3218 case 1702620169: /*bodySite*/ return this.bodySite == null ? new Base[0] : new Base[] {this.bodySite}; // CodeableConcept 3219 case 109757182: /*stage*/ return this.stage == null ? new Base[0] : new Base[] {this.stage}; // CodeableConcept 3220 case 57790391: /*hasSeverity*/ return this.hasSeverity == null ? new Base[0] : new Base[] {this.hasSeverity}; // BooleanType 3221 case 282110147: /*hasBodySite*/ return this.hasBodySite == null ? new Base[0] : new Base[] {this.hasBodySite}; // BooleanType 3222 case 129749124: /*hasStage*/ return this.hasStage == null ? new Base[0] : new Base[] {this.hasStage}; // BooleanType 3223 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : this.definition.toArray(new Base[this.definition.size()]); // UriType 3224 case 122345516: /*observation*/ return this.observation == null ? new Base[0] : this.observation.toArray(new Base[this.observation.size()]); // ConditionDefinitionObservationComponent 3225 case 1998965455: /*medication*/ return this.medication == null ? new Base[0] : this.medication.toArray(new Base[this.medication.size()]); // ConditionDefinitionMedicationComponent 3226 case -650968616: /*precondition*/ return this.precondition == null ? new Base[0] : this.precondition.toArray(new Base[this.precondition.size()]); // ConditionDefinitionPreconditionComponent 3227 case 3555933: /*team*/ return this.team == null ? new Base[0] : this.team.toArray(new Base[this.team.size()]); // Reference 3228 case -1017049693: /*questionnaire*/ return this.questionnaire == null ? new Base[0] : this.questionnaire.toArray(new Base[this.questionnaire.size()]); // ConditionDefinitionQuestionnaireComponent 3229 case 3443497: /*plan*/ return this.plan == null ? new Base[0] : this.plan.toArray(new Base[this.plan.size()]); // ConditionDefinitionPlanComponent 3230 default: return super.getProperty(hash, name, checkValid); 3231 } 3232 3233 } 3234 3235 @Override 3236 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3237 switch (hash) { 3238 case 116079: // url 3239 this.url = TypeConvertor.castToUri(value); // UriType 3240 return value; 3241 case -1618432855: // identifier 3242 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier 3243 return value; 3244 case 351608024: // version 3245 this.version = TypeConvertor.castToString(value); // StringType 3246 return value; 3247 case 3373707: // name 3248 this.name = TypeConvertor.castToString(value); // StringType 3249 return value; 3250 case 110371416: // title 3251 this.title = TypeConvertor.castToString(value); // StringType 3252 return value; 3253 case -2060497896: // subtitle 3254 this.subtitle = TypeConvertor.castToString(value); // StringType 3255 return value; 3256 case -892481550: // status 3257 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 3258 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 3259 return value; 3260 case -404562712: // experimental 3261 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 3262 return value; 3263 case 3076014: // date 3264 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 3265 return value; 3266 case 1447404028: // publisher 3267 this.publisher = TypeConvertor.castToString(value); // StringType 3268 return value; 3269 case 951526432: // contact 3270 this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail 3271 return value; 3272 case -1724546052: // description 3273 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 3274 return value; 3275 case -669707736: // useContext 3276 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext 3277 return value; 3278 case -507075711: // jurisdiction 3279 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept 3280 return value; 3281 case 3059181: // code 3282 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3283 return value; 3284 case 1478300413: // severity 3285 this.severity = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3286 return value; 3287 case 1702620169: // bodySite 3288 this.bodySite = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3289 return value; 3290 case 109757182: // stage 3291 this.stage = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3292 return value; 3293 case 57790391: // hasSeverity 3294 this.hasSeverity = TypeConvertor.castToBoolean(value); // BooleanType 3295 return value; 3296 case 282110147: // hasBodySite 3297 this.hasBodySite = TypeConvertor.castToBoolean(value); // BooleanType 3298 return value; 3299 case 129749124: // hasStage 3300 this.hasStage = TypeConvertor.castToBoolean(value); // BooleanType 3301 return value; 3302 case -1014418093: // definition 3303 this.getDefinition().add(TypeConvertor.castToUri(value)); // UriType 3304 return value; 3305 case 122345516: // observation 3306 this.getObservation().add((ConditionDefinitionObservationComponent) value); // ConditionDefinitionObservationComponent 3307 return value; 3308 case 1998965455: // medication 3309 this.getMedication().add((ConditionDefinitionMedicationComponent) value); // ConditionDefinitionMedicationComponent 3310 return value; 3311 case -650968616: // precondition 3312 this.getPrecondition().add((ConditionDefinitionPreconditionComponent) value); // ConditionDefinitionPreconditionComponent 3313 return value; 3314 case 3555933: // team 3315 this.getTeam().add(TypeConvertor.castToReference(value)); // Reference 3316 return value; 3317 case -1017049693: // questionnaire 3318 this.getQuestionnaire().add((ConditionDefinitionQuestionnaireComponent) value); // ConditionDefinitionQuestionnaireComponent 3319 return value; 3320 case 3443497: // plan 3321 this.getPlan().add((ConditionDefinitionPlanComponent) value); // ConditionDefinitionPlanComponent 3322 return value; 3323 default: return super.setProperty(hash, name, value); 3324 } 3325 3326 } 3327 3328 @Override 3329 public Base setProperty(String name, Base value) throws FHIRException { 3330 if (name.equals("url")) { 3331 this.url = TypeConvertor.castToUri(value); // UriType 3332 } else if (name.equals("identifier")) { 3333 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); 3334 } else if (name.equals("version")) { 3335 this.version = TypeConvertor.castToString(value); // StringType 3336 } else if (name.equals("name")) { 3337 this.name = TypeConvertor.castToString(value); // StringType 3338 } else if (name.equals("title")) { 3339 this.title = TypeConvertor.castToString(value); // StringType 3340 } else if (name.equals("subtitle")) { 3341 this.subtitle = TypeConvertor.castToString(value); // StringType 3342 } else if (name.equals("status")) { 3343 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 3344 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 3345 } else if (name.equals("experimental")) { 3346 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 3347 } else if (name.equals("date")) { 3348 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 3349 } else if (name.equals("publisher")) { 3350 this.publisher = TypeConvertor.castToString(value); // StringType 3351 } else if (name.equals("contact")) { 3352 this.getContact().add(TypeConvertor.castToContactDetail(value)); 3353 } else if (name.equals("description")) { 3354 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 3355 } else if (name.equals("useContext")) { 3356 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); 3357 } else if (name.equals("jurisdiction")) { 3358 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); 3359 } else if (name.equals("code")) { 3360 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3361 } else if (name.equals("severity")) { 3362 this.severity = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3363 } else if (name.equals("bodySite")) { 3364 this.bodySite = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3365 } else if (name.equals("stage")) { 3366 this.stage = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 3367 } else if (name.equals("hasSeverity")) { 3368 this.hasSeverity = TypeConvertor.castToBoolean(value); // BooleanType 3369 } else if (name.equals("hasBodySite")) { 3370 this.hasBodySite = TypeConvertor.castToBoolean(value); // BooleanType 3371 } else if (name.equals("hasStage")) { 3372 this.hasStage = TypeConvertor.castToBoolean(value); // BooleanType 3373 } else if (name.equals("definition")) { 3374 this.getDefinition().add(TypeConvertor.castToUri(value)); 3375 } else if (name.equals("observation")) { 3376 this.getObservation().add((ConditionDefinitionObservationComponent) value); 3377 } else if (name.equals("medication")) { 3378 this.getMedication().add((ConditionDefinitionMedicationComponent) value); 3379 } else if (name.equals("precondition")) { 3380 this.getPrecondition().add((ConditionDefinitionPreconditionComponent) value); 3381 } else if (name.equals("team")) { 3382 this.getTeam().add(TypeConvertor.castToReference(value)); 3383 } else if (name.equals("questionnaire")) { 3384 this.getQuestionnaire().add((ConditionDefinitionQuestionnaireComponent) value); 3385 } else if (name.equals("plan")) { 3386 this.getPlan().add((ConditionDefinitionPlanComponent) value); 3387 } else 3388 return super.setProperty(name, value); 3389 return value; 3390 } 3391 3392 @Override 3393 public Base makeProperty(int hash, String name) throws FHIRException { 3394 switch (hash) { 3395 case 116079: return getUrlElement(); 3396 case -1618432855: return addIdentifier(); 3397 case 351608024: return getVersionElement(); 3398 case 3373707: return getNameElement(); 3399 case 110371416: return getTitleElement(); 3400 case -2060497896: return getSubtitleElement(); 3401 case -892481550: return getStatusElement(); 3402 case -404562712: return getExperimentalElement(); 3403 case 3076014: return getDateElement(); 3404 case 1447404028: return getPublisherElement(); 3405 case 951526432: return addContact(); 3406 case -1724546052: return getDescriptionElement(); 3407 case -669707736: return addUseContext(); 3408 case -507075711: return addJurisdiction(); 3409 case 3059181: return getCode(); 3410 case 1478300413: return getSeverity(); 3411 case 1702620169: return getBodySite(); 3412 case 109757182: return getStage(); 3413 case 57790391: return getHasSeverityElement(); 3414 case 282110147: return getHasBodySiteElement(); 3415 case 129749124: return getHasStageElement(); 3416 case -1014418093: return addDefinitionElement(); 3417 case 122345516: return addObservation(); 3418 case 1998965455: return addMedication(); 3419 case -650968616: return addPrecondition(); 3420 case 3555933: return addTeam(); 3421 case -1017049693: return addQuestionnaire(); 3422 case 3443497: return addPlan(); 3423 default: return super.makeProperty(hash, name); 3424 } 3425 3426 } 3427 3428 @Override 3429 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3430 switch (hash) { 3431 case 116079: /*url*/ return new String[] {"uri"}; 3432 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 3433 case 351608024: /*version*/ return new String[] {"string"}; 3434 case 3373707: /*name*/ return new String[] {"string"}; 3435 case 110371416: /*title*/ return new String[] {"string"}; 3436 case -2060497896: /*subtitle*/ return new String[] {"string"}; 3437 case -892481550: /*status*/ return new String[] {"code"}; 3438 case -404562712: /*experimental*/ return new String[] {"boolean"}; 3439 case 3076014: /*date*/ return new String[] {"dateTime"}; 3440 case 1447404028: /*publisher*/ return new String[] {"string"}; 3441 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 3442 case -1724546052: /*description*/ return new String[] {"markdown"}; 3443 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 3444 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 3445 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 3446 case 1478300413: /*severity*/ return new String[] {"CodeableConcept"}; 3447 case 1702620169: /*bodySite*/ return new String[] {"CodeableConcept"}; 3448 case 109757182: /*stage*/ return new String[] {"CodeableConcept"}; 3449 case 57790391: /*hasSeverity*/ return new String[] {"boolean"}; 3450 case 282110147: /*hasBodySite*/ return new String[] {"boolean"}; 3451 case 129749124: /*hasStage*/ return new String[] {"boolean"}; 3452 case -1014418093: /*definition*/ return new String[] {"uri"}; 3453 case 122345516: /*observation*/ return new String[] {}; 3454 case 1998965455: /*medication*/ return new String[] {}; 3455 case -650968616: /*precondition*/ return new String[] {}; 3456 case 3555933: /*team*/ return new String[] {"Reference"}; 3457 case -1017049693: /*questionnaire*/ return new String[] {}; 3458 case 3443497: /*plan*/ return new String[] {}; 3459 default: return super.getTypesForProperty(hash, name); 3460 } 3461 3462 } 3463 3464 @Override 3465 public Base addChild(String name) throws FHIRException { 3466 if (name.equals("url")) { 3467 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.url"); 3468 } 3469 else if (name.equals("identifier")) { 3470 return addIdentifier(); 3471 } 3472 else if (name.equals("version")) { 3473 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.version"); 3474 } 3475 else if (name.equals("name")) { 3476 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.name"); 3477 } 3478 else if (name.equals("title")) { 3479 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.title"); 3480 } 3481 else if (name.equals("subtitle")) { 3482 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.subtitle"); 3483 } 3484 else if (name.equals("status")) { 3485 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.status"); 3486 } 3487 else if (name.equals("experimental")) { 3488 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.experimental"); 3489 } 3490 else if (name.equals("date")) { 3491 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.date"); 3492 } 3493 else if (name.equals("publisher")) { 3494 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.publisher"); 3495 } 3496 else if (name.equals("contact")) { 3497 return addContact(); 3498 } 3499 else if (name.equals("description")) { 3500 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.description"); 3501 } 3502 else if (name.equals("useContext")) { 3503 return addUseContext(); 3504 } 3505 else if (name.equals("jurisdiction")) { 3506 return addJurisdiction(); 3507 } 3508 else if (name.equals("code")) { 3509 this.code = new CodeableConcept(); 3510 return this.code; 3511 } 3512 else if (name.equals("severity")) { 3513 this.severity = new CodeableConcept(); 3514 return this.severity; 3515 } 3516 else if (name.equals("bodySite")) { 3517 this.bodySite = new CodeableConcept(); 3518 return this.bodySite; 3519 } 3520 else if (name.equals("stage")) { 3521 this.stage = new CodeableConcept(); 3522 return this.stage; 3523 } 3524 else if (name.equals("hasSeverity")) { 3525 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.hasSeverity"); 3526 } 3527 else if (name.equals("hasBodySite")) { 3528 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.hasBodySite"); 3529 } 3530 else if (name.equals("hasStage")) { 3531 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.hasStage"); 3532 } 3533 else if (name.equals("definition")) { 3534 throw new FHIRException("Cannot call addChild on a primitive type ConditionDefinition.definition"); 3535 } 3536 else if (name.equals("observation")) { 3537 return addObservation(); 3538 } 3539 else if (name.equals("medication")) { 3540 return addMedication(); 3541 } 3542 else if (name.equals("precondition")) { 3543 return addPrecondition(); 3544 } 3545 else if (name.equals("team")) { 3546 return addTeam(); 3547 } 3548 else if (name.equals("questionnaire")) { 3549 return addQuestionnaire(); 3550 } 3551 else if (name.equals("plan")) { 3552 return addPlan(); 3553 } 3554 else 3555 return super.addChild(name); 3556 } 3557 3558 public String fhirType() { 3559 return "ConditionDefinition"; 3560 3561 } 3562 3563 public ConditionDefinition copy() { 3564 ConditionDefinition dst = new ConditionDefinition(); 3565 copyValues(dst); 3566 return dst; 3567 } 3568 3569 public void copyValues(ConditionDefinition dst) { 3570 super.copyValues(dst); 3571 dst.url = url == null ? null : url.copy(); 3572 if (identifier != null) { 3573 dst.identifier = new ArrayList<Identifier>(); 3574 for (Identifier i : identifier) 3575 dst.identifier.add(i.copy()); 3576 }; 3577 dst.version = version == null ? null : version.copy(); 3578 dst.name = name == null ? null : name.copy(); 3579 dst.title = title == null ? null : title.copy(); 3580 dst.subtitle = subtitle == null ? null : subtitle.copy(); 3581 dst.status = status == null ? null : status.copy(); 3582 dst.experimental = experimental == null ? null : experimental.copy(); 3583 dst.date = date == null ? null : date.copy(); 3584 dst.publisher = publisher == null ? null : publisher.copy(); 3585 if (contact != null) { 3586 dst.contact = new ArrayList<ContactDetail>(); 3587 for (ContactDetail i : contact) 3588 dst.contact.add(i.copy()); 3589 }; 3590 dst.description = description == null ? null : description.copy(); 3591 if (useContext != null) { 3592 dst.useContext = new ArrayList<UsageContext>(); 3593 for (UsageContext i : useContext) 3594 dst.useContext.add(i.copy()); 3595 }; 3596 if (jurisdiction != null) { 3597 dst.jurisdiction = new ArrayList<CodeableConcept>(); 3598 for (CodeableConcept i : jurisdiction) 3599 dst.jurisdiction.add(i.copy()); 3600 }; 3601 dst.code = code == null ? null : code.copy(); 3602 dst.severity = severity == null ? null : severity.copy(); 3603 dst.bodySite = bodySite == null ? null : bodySite.copy(); 3604 dst.stage = stage == null ? null : stage.copy(); 3605 dst.hasSeverity = hasSeverity == null ? null : hasSeverity.copy(); 3606 dst.hasBodySite = hasBodySite == null ? null : hasBodySite.copy(); 3607 dst.hasStage = hasStage == null ? null : hasStage.copy(); 3608 if (definition != null) { 3609 dst.definition = new ArrayList<UriType>(); 3610 for (UriType i : definition) 3611 dst.definition.add(i.copy()); 3612 }; 3613 if (observation != null) { 3614 dst.observation = new ArrayList<ConditionDefinitionObservationComponent>(); 3615 for (ConditionDefinitionObservationComponent i : observation) 3616 dst.observation.add(i.copy()); 3617 }; 3618 if (medication != null) { 3619 dst.medication = new ArrayList<ConditionDefinitionMedicationComponent>(); 3620 for (ConditionDefinitionMedicationComponent i : medication) 3621 dst.medication.add(i.copy()); 3622 }; 3623 if (precondition != null) { 3624 dst.precondition = new ArrayList<ConditionDefinitionPreconditionComponent>(); 3625 for (ConditionDefinitionPreconditionComponent i : precondition) 3626 dst.precondition.add(i.copy()); 3627 }; 3628 if (team != null) { 3629 dst.team = new ArrayList<Reference>(); 3630 for (Reference i : team) 3631 dst.team.add(i.copy()); 3632 }; 3633 if (questionnaire != null) { 3634 dst.questionnaire = new ArrayList<ConditionDefinitionQuestionnaireComponent>(); 3635 for (ConditionDefinitionQuestionnaireComponent i : questionnaire) 3636 dst.questionnaire.add(i.copy()); 3637 }; 3638 if (plan != null) { 3639 dst.plan = new ArrayList<ConditionDefinitionPlanComponent>(); 3640 for (ConditionDefinitionPlanComponent i : plan) 3641 dst.plan.add(i.copy()); 3642 }; 3643 } 3644 3645 protected ConditionDefinition typedCopy() { 3646 return copy(); 3647 } 3648 3649 @Override 3650 public boolean equalsDeep(Base other_) { 3651 if (!super.equalsDeep(other_)) 3652 return false; 3653 if (!(other_ instanceof ConditionDefinition)) 3654 return false; 3655 ConditionDefinition o = (ConditionDefinition) other_; 3656 return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true) 3657 && compareDeep(name, o.name, true) && compareDeep(title, o.title, true) && compareDeep(subtitle, o.subtitle, true) 3658 && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true) 3659 && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true) 3660 && compareDeep(useContext, o.useContext, true) && compareDeep(jurisdiction, o.jurisdiction, true) 3661 && compareDeep(code, o.code, true) && compareDeep(severity, o.severity, true) && compareDeep(bodySite, o.bodySite, true) 3662 && compareDeep(stage, o.stage, true) && compareDeep(hasSeverity, o.hasSeverity, true) && compareDeep(hasBodySite, o.hasBodySite, true) 3663 && compareDeep(hasStage, o.hasStage, true) && compareDeep(definition, o.definition, true) && compareDeep(observation, o.observation, true) 3664 && compareDeep(medication, o.medication, true) && compareDeep(precondition, o.precondition, true) 3665 && compareDeep(team, o.team, true) && compareDeep(questionnaire, o.questionnaire, true) && compareDeep(plan, o.plan, true) 3666 ; 3667 } 3668 3669 @Override 3670 public boolean equalsShallow(Base other_) { 3671 if (!super.equalsShallow(other_)) 3672 return false; 3673 if (!(other_ instanceof ConditionDefinition)) 3674 return false; 3675 ConditionDefinition o = (ConditionDefinition) other_; 3676 return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true) 3677 && compareValues(title, o.title, true) && compareValues(subtitle, o.subtitle, true) && compareValues(status, o.status, true) 3678 && compareValues(experimental, o.experimental, true) && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) 3679 && compareValues(description, o.description, true) && compareValues(hasSeverity, o.hasSeverity, true) 3680 && compareValues(hasBodySite, o.hasBodySite, true) && compareValues(hasStage, o.hasStage, true) && compareValues(definition, o.definition, true) 3681 ; 3682 } 3683 3684 public boolean isEmpty() { 3685 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version 3686 , name, title, subtitle, status, experimental, date, publisher, contact, description 3687 , useContext, jurisdiction, code, severity, bodySite, stage, hasSeverity, hasBodySite 3688 , hasStage, definition, observation, medication, precondition, team, questionnaire 3689 , plan); 3690 } 3691 3692 @Override 3693 public ResourceType getResourceType() { 3694 return ResourceType.ConditionDefinition; 3695 } 3696 3697 /** 3698 * Search parameter: <b>context-quantity</b> 3699 * <p> 3700 * Description: <b>A quantity- or range-valued use context assigned to the condition definition</b><br> 3701 * Type: <b>quantity</b><br> 3702 * Path: <b>(ConditionDefinition.useContext.value as Quantity) | (ConditionDefinition.useContext.value as Range)</b><br> 3703 * </p> 3704 */ 3705 @SearchParamDefinition(name="context-quantity", path="(ConditionDefinition.useContext.value as Quantity) | (ConditionDefinition.useContext.value as Range)", description="A quantity- or range-valued use context assigned to the condition definition", type="quantity" ) 3706 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 3707 /** 3708 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 3709 * <p> 3710 * Description: <b>A quantity- or range-valued use context assigned to the condition definition</b><br> 3711 * Type: <b>quantity</b><br> 3712 * Path: <b>(ConditionDefinition.useContext.value as Quantity) | (ConditionDefinition.useContext.value as Range)</b><br> 3713 * </p> 3714 */ 3715 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY); 3716 3717 /** 3718 * Search parameter: <b>context-type-quantity</b> 3719 * <p> 3720 * Description: <b>A use context type and quantity- or range-based value assigned to the condition definition</b><br> 3721 * Type: <b>composite</b><br> 3722 * Path: <b>ConditionDefinition.useContext</b><br> 3723 * </p> 3724 */ 3725 @SearchParamDefinition(name="context-type-quantity", path="ConditionDefinition.useContext", description="A use context type and quantity- or range-based value assigned to the condition definition", type="composite", compositeOf={"context-type", "context-quantity"} ) 3726 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 3727 /** 3728 * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b> 3729 * <p> 3730 * Description: <b>A use context type and quantity- or range-based value assigned to the condition definition</b><br> 3731 * Type: <b>composite</b><br> 3732 * Path: <b>ConditionDefinition.useContext</b><br> 3733 * </p> 3734 */ 3735 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(SP_CONTEXT_TYPE_QUANTITY); 3736 3737 /** 3738 * Search parameter: <b>context-type-value</b> 3739 * <p> 3740 * Description: <b>A use context type and value assigned to the condition definition</b><br> 3741 * Type: <b>composite</b><br> 3742 * Path: <b>ConditionDefinition.useContext</b><br> 3743 * </p> 3744 */ 3745 @SearchParamDefinition(name="context-type-value", path="ConditionDefinition.useContext", description="A use context type and value assigned to the condition definition", type="composite", compositeOf={"context-type", "context"} ) 3746 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 3747 /** 3748 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 3749 * <p> 3750 * Description: <b>A use context type and value assigned to the condition definition</b><br> 3751 * Type: <b>composite</b><br> 3752 * Path: <b>ConditionDefinition.useContext</b><br> 3753 * </p> 3754 */ 3755 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CONTEXT_TYPE_VALUE); 3756 3757 /** 3758 * Search parameter: <b>context-type</b> 3759 * <p> 3760 * Description: <b>A type of use context assigned to the condition definition</b><br> 3761 * Type: <b>token</b><br> 3762 * Path: <b>ConditionDefinition.useContext.code</b><br> 3763 * </p> 3764 */ 3765 @SearchParamDefinition(name="context-type", path="ConditionDefinition.useContext.code", description="A type of use context assigned to the condition definition", type="token" ) 3766 public static final String SP_CONTEXT_TYPE = "context-type"; 3767 /** 3768 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 3769 * <p> 3770 * Description: <b>A type of use context assigned to the condition definition</b><br> 3771 * Type: <b>token</b><br> 3772 * Path: <b>ConditionDefinition.useContext.code</b><br> 3773 * </p> 3774 */ 3775 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE); 3776 3777 /** 3778 * Search parameter: <b>context</b> 3779 * <p> 3780 * Description: <b>A use context assigned to the condition definition</b><br> 3781 * Type: <b>token</b><br> 3782 * Path: <b>(ConditionDefinition.useContext.value as CodeableConcept)</b><br> 3783 * </p> 3784 */ 3785 @SearchParamDefinition(name="context", path="(ConditionDefinition.useContext.value as CodeableConcept)", description="A use context assigned to the condition definition", type="token" ) 3786 public static final String SP_CONTEXT = "context"; 3787 /** 3788 * <b>Fluent Client</b> search parameter constant for <b>context</b> 3789 * <p> 3790 * Description: <b>A use context assigned to the condition definition</b><br> 3791 * Type: <b>token</b><br> 3792 * Path: <b>(ConditionDefinition.useContext.value as CodeableConcept)</b><br> 3793 * </p> 3794 */ 3795 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT); 3796 3797 /** 3798 * Search parameter: <b>date</b> 3799 * <p> 3800 * Description: <b>The condition definition publication date</b><br> 3801 * Type: <b>date</b><br> 3802 * Path: <b>ConditionDefinition.date</b><br> 3803 * </p> 3804 */ 3805 @SearchParamDefinition(name="date", path="ConditionDefinition.date", description="The condition definition publication date", type="date" ) 3806 public static final String SP_DATE = "date"; 3807 /** 3808 * <b>Fluent Client</b> search parameter constant for <b>date</b> 3809 * <p> 3810 * Description: <b>The condition definition publication date</b><br> 3811 * Type: <b>date</b><br> 3812 * Path: <b>ConditionDefinition.date</b><br> 3813 * </p> 3814 */ 3815 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 3816 3817 /** 3818 * Search parameter: <b>description</b> 3819 * <p> 3820 * Description: <b>The description of the condition definition</b><br> 3821 * Type: <b>string</b><br> 3822 * Path: <b>ConditionDefinition.description</b><br> 3823 * </p> 3824 */ 3825 @SearchParamDefinition(name="description", path="ConditionDefinition.description", description="The description of the condition definition", type="string" ) 3826 public static final String SP_DESCRIPTION = "description"; 3827 /** 3828 * <b>Fluent Client</b> search parameter constant for <b>description</b> 3829 * <p> 3830 * Description: <b>The description of the condition definition</b><br> 3831 * Type: <b>string</b><br> 3832 * Path: <b>ConditionDefinition.description</b><br> 3833 * </p> 3834 */ 3835 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 3836 3837 /** 3838 * Search parameter: <b>identifier</b> 3839 * <p> 3840 * Description: <b>External identifier for the condition definition</b><br> 3841 * Type: <b>token</b><br> 3842 * Path: <b>ConditionDefinition.identifier</b><br> 3843 * </p> 3844 */ 3845 @SearchParamDefinition(name="identifier", path="ConditionDefinition.identifier", description="External identifier for the condition definition", type="token" ) 3846 public static final String SP_IDENTIFIER = "identifier"; 3847 /** 3848 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 3849 * <p> 3850 * Description: <b>External identifier for the condition definition</b><br> 3851 * Type: <b>token</b><br> 3852 * Path: <b>ConditionDefinition.identifier</b><br> 3853 * </p> 3854 */ 3855 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 3856 3857 /** 3858 * Search parameter: <b>jurisdiction</b> 3859 * <p> 3860 * Description: <b>Intended jurisdiction for the condition definition</b><br> 3861 * Type: <b>token</b><br> 3862 * Path: <b>ConditionDefinition.jurisdiction</b><br> 3863 * </p> 3864 */ 3865 @SearchParamDefinition(name="jurisdiction", path="ConditionDefinition.jurisdiction", description="Intended jurisdiction for the condition definition", type="token" ) 3866 public static final String SP_JURISDICTION = "jurisdiction"; 3867 /** 3868 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 3869 * <p> 3870 * Description: <b>Intended jurisdiction for the condition definition</b><br> 3871 * Type: <b>token</b><br> 3872 * Path: <b>ConditionDefinition.jurisdiction</b><br> 3873 * </p> 3874 */ 3875 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 3876 3877 /** 3878 * Search parameter: <b>name</b> 3879 * <p> 3880 * Description: <b>Computationally friendly name of the condition definition</b><br> 3881 * Type: <b>string</b><br> 3882 * Path: <b>ConditionDefinition.name</b><br> 3883 * </p> 3884 */ 3885 @SearchParamDefinition(name="name", path="ConditionDefinition.name", description="Computationally friendly name of the condition definition", type="string" ) 3886 public static final String SP_NAME = "name"; 3887 /** 3888 * <b>Fluent Client</b> search parameter constant for <b>name</b> 3889 * <p> 3890 * Description: <b>Computationally friendly name of the condition definition</b><br> 3891 * Type: <b>string</b><br> 3892 * Path: <b>ConditionDefinition.name</b><br> 3893 * </p> 3894 */ 3895 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 3896 3897 /** 3898 * Search parameter: <b>publisher</b> 3899 * <p> 3900 * Description: <b>Name of the publisher of the condition definition</b><br> 3901 * Type: <b>string</b><br> 3902 * Path: <b>ConditionDefinition.publisher</b><br> 3903 * </p> 3904 */ 3905 @SearchParamDefinition(name="publisher", path="ConditionDefinition.publisher", description="Name of the publisher of the condition definition", type="string" ) 3906 public static final String SP_PUBLISHER = "publisher"; 3907 /** 3908 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 3909 * <p> 3910 * Description: <b>Name of the publisher of the condition definition</b><br> 3911 * Type: <b>string</b><br> 3912 * Path: <b>ConditionDefinition.publisher</b><br> 3913 * </p> 3914 */ 3915 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 3916 3917 /** 3918 * Search parameter: <b>status</b> 3919 * <p> 3920 * Description: <b>The current status of the condition definition</b><br> 3921 * Type: <b>token</b><br> 3922 * Path: <b>ConditionDefinition.status</b><br> 3923 * </p> 3924 */ 3925 @SearchParamDefinition(name="status", path="ConditionDefinition.status", description="The current status of the condition definition", type="token" ) 3926 public static final String SP_STATUS = "status"; 3927 /** 3928 * <b>Fluent Client</b> search parameter constant for <b>status</b> 3929 * <p> 3930 * Description: <b>The current status of the condition definition</b><br> 3931 * Type: <b>token</b><br> 3932 * Path: <b>ConditionDefinition.status</b><br> 3933 * </p> 3934 */ 3935 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 3936 3937 /** 3938 * Search parameter: <b>title</b> 3939 * <p> 3940 * Description: <b>The human-friendly name of the condition definition</b><br> 3941 * Type: <b>string</b><br> 3942 * Path: <b>ConditionDefinition.title</b><br> 3943 * </p> 3944 */ 3945 @SearchParamDefinition(name="title", path="ConditionDefinition.title", description="The human-friendly name of the condition definition", type="string" ) 3946 public static final String SP_TITLE = "title"; 3947 /** 3948 * <b>Fluent Client</b> search parameter constant for <b>title</b> 3949 * <p> 3950 * Description: <b>The human-friendly name of the condition definition</b><br> 3951 * Type: <b>string</b><br> 3952 * Path: <b>ConditionDefinition.title</b><br> 3953 * </p> 3954 */ 3955 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE); 3956 3957 /** 3958 * Search parameter: <b>url</b> 3959 * <p> 3960 * Description: <b>The uri that identifies the condition definition</b><br> 3961 * Type: <b>uri</b><br> 3962 * Path: <b>ConditionDefinition.url</b><br> 3963 * </p> 3964 */ 3965 @SearchParamDefinition(name="url", path="ConditionDefinition.url", description="The uri that identifies the condition definition", type="uri" ) 3966 public static final String SP_URL = "url"; 3967 /** 3968 * <b>Fluent Client</b> search parameter constant for <b>url</b> 3969 * <p> 3970 * Description: <b>The uri that identifies the condition definition</b><br> 3971 * Type: <b>uri</b><br> 3972 * Path: <b>ConditionDefinition.url</b><br> 3973 * </p> 3974 */ 3975 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 3976 3977 /** 3978 * Search parameter: <b>version</b> 3979 * <p> 3980 * Description: <b>The business version of the condition definition</b><br> 3981 * Type: <b>token</b><br> 3982 * Path: <b>ConditionDefinition.version</b><br> 3983 * </p> 3984 */ 3985 @SearchParamDefinition(name="version", path="ConditionDefinition.version", description="The business version of the condition definition", type="token" ) 3986 public static final String SP_VERSION = "version"; 3987 /** 3988 * <b>Fluent Client</b> search parameter constant for <b>version</b> 3989 * <p> 3990 * Description: <b>The business version of the condition definition</b><br> 3991 * Type: <b>token</b><br> 3992 * Path: <b>ConditionDefinition.version</b><br> 3993 * </p> 3994 */ 3995 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 3996 3997 3998} 3999