001package org.hl7.fhir.r4b.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Fri, Dec 31, 2021 05:58+1100 for FHIR v4.3.0-snapshot1 033 034import java.util.ArrayList; 035import java.util.Date; 036import java.util.List; 037import org.hl7.fhir.utilities.Utilities; 038import org.hl7.fhir.r4b.model.Enumerations.*; 039import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 040import org.hl7.fhir.exceptions.FHIRException; 041import org.hl7.fhir.instance.model.api.ICompositeType; 042import ca.uhn.fhir.model.api.annotation.ResourceDef; 043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 044import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 045import ca.uhn.fhir.model.api.annotation.Child; 046import ca.uhn.fhir.model.api.annotation.ChildOrder; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.Block; 049 050/** 051 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 052 */ 053@ResourceDef(name="AllergyIntolerance", profile="http://hl7.org/fhir/StructureDefinition/AllergyIntolerance") 054public class AllergyIntolerance extends DomainResource { 055 056 public enum AllergyIntoleranceCategory { 057 /** 058 * Any substance consumed to provide nutritional support for the body. 059 */ 060 FOOD, 061 /** 062 * Substances administered to achieve a physiological effect. 063 */ 064 MEDICATION, 065 /** 066 * Any substances that are encountered in the environment, including any substance not already classified as food, medication, or biologic. 067 */ 068 ENVIRONMENT, 069 /** 070 * A preparation that is synthesized from living organisms or their products, especially a human or animal protein, such as a hormone or antitoxin, that is used as a diagnostic, preventive, or therapeutic agent. Examples of biologic medications include: vaccines; allergenic extracts, which are used for both diagnosis and treatment (for example, allergy shots); gene therapies; cellular therapies. There are other biologic products, such as tissues, which are not typically associated with allergies. 071 */ 072 BIOLOGIC, 073 /** 074 * added to help the parsers with the generic types 075 */ 076 NULL; 077 public static AllergyIntoleranceCategory fromCode(String codeString) throws FHIRException { 078 if (codeString == null || "".equals(codeString)) 079 return null; 080 if ("food".equals(codeString)) 081 return FOOD; 082 if ("medication".equals(codeString)) 083 return MEDICATION; 084 if ("environment".equals(codeString)) 085 return ENVIRONMENT; 086 if ("biologic".equals(codeString)) 087 return BIOLOGIC; 088 if (Configuration.isAcceptInvalidEnums()) 089 return null; 090 else 091 throw new FHIRException("Unknown AllergyIntoleranceCategory code '"+codeString+"'"); 092 } 093 public String toCode() { 094 switch (this) { 095 case FOOD: return "food"; 096 case MEDICATION: return "medication"; 097 case ENVIRONMENT: return "environment"; 098 case BIOLOGIC: return "biologic"; 099 case NULL: return null; 100 default: return "?"; 101 } 102 } 103 public String getSystem() { 104 switch (this) { 105 case FOOD: return "http://hl7.org/fhir/allergy-intolerance-category"; 106 case MEDICATION: return "http://hl7.org/fhir/allergy-intolerance-category"; 107 case ENVIRONMENT: return "http://hl7.org/fhir/allergy-intolerance-category"; 108 case BIOLOGIC: return "http://hl7.org/fhir/allergy-intolerance-category"; 109 case NULL: return null; 110 default: return "?"; 111 } 112 } 113 public String getDefinition() { 114 switch (this) { 115 case FOOD: return "Any substance consumed to provide nutritional support for the body."; 116 case MEDICATION: return "Substances administered to achieve a physiological effect."; 117 case ENVIRONMENT: return "Any substances that are encountered in the environment, including any substance not already classified as food, medication, or biologic."; 118 case BIOLOGIC: return "A preparation that is synthesized from living organisms or their products, especially a human or animal protein, such as a hormone or antitoxin, that is used as a diagnostic, preventive, or therapeutic agent. Examples of biologic medications include: vaccines; allergenic extracts, which are used for both diagnosis and treatment (for example, allergy shots); gene therapies; cellular therapies. There are other biologic products, such as tissues, which are not typically associated with allergies."; 119 case NULL: return null; 120 default: return "?"; 121 } 122 } 123 public String getDisplay() { 124 switch (this) { 125 case FOOD: return "Food"; 126 case MEDICATION: return "Medication"; 127 case ENVIRONMENT: return "Environment"; 128 case BIOLOGIC: return "Biologic"; 129 case NULL: return null; 130 default: return "?"; 131 } 132 } 133 } 134 135 public static class AllergyIntoleranceCategoryEnumFactory implements EnumFactory<AllergyIntoleranceCategory> { 136 public AllergyIntoleranceCategory fromCode(String codeString) throws IllegalArgumentException { 137 if (codeString == null || "".equals(codeString)) 138 if (codeString == null || "".equals(codeString)) 139 return null; 140 if ("food".equals(codeString)) 141 return AllergyIntoleranceCategory.FOOD; 142 if ("medication".equals(codeString)) 143 return AllergyIntoleranceCategory.MEDICATION; 144 if ("environment".equals(codeString)) 145 return AllergyIntoleranceCategory.ENVIRONMENT; 146 if ("biologic".equals(codeString)) 147 return AllergyIntoleranceCategory.BIOLOGIC; 148 throw new IllegalArgumentException("Unknown AllergyIntoleranceCategory code '"+codeString+"'"); 149 } 150 public Enumeration<AllergyIntoleranceCategory> fromType(Base code) throws FHIRException { 151 if (code == null) 152 return null; 153 if (code.isEmpty()) 154 return new Enumeration<AllergyIntoleranceCategory>(this); 155 String codeString = ((PrimitiveType) code).asStringValue(); 156 if (codeString == null || "".equals(codeString)) 157 return null; 158 if ("food".equals(codeString)) 159 return new Enumeration<AllergyIntoleranceCategory>(this, AllergyIntoleranceCategory.FOOD); 160 if ("medication".equals(codeString)) 161 return new Enumeration<AllergyIntoleranceCategory>(this, AllergyIntoleranceCategory.MEDICATION); 162 if ("environment".equals(codeString)) 163 return new Enumeration<AllergyIntoleranceCategory>(this, AllergyIntoleranceCategory.ENVIRONMENT); 164 if ("biologic".equals(codeString)) 165 return new Enumeration<AllergyIntoleranceCategory>(this, AllergyIntoleranceCategory.BIOLOGIC); 166 throw new FHIRException("Unknown AllergyIntoleranceCategory code '"+codeString+"'"); 167 } 168 public String toCode(AllergyIntoleranceCategory code) { 169 if (code == AllergyIntoleranceCategory.FOOD) 170 return "food"; 171 if (code == AllergyIntoleranceCategory.MEDICATION) 172 return "medication"; 173 if (code == AllergyIntoleranceCategory.ENVIRONMENT) 174 return "environment"; 175 if (code == AllergyIntoleranceCategory.BIOLOGIC) 176 return "biologic"; 177 return "?"; 178 } 179 public String toSystem(AllergyIntoleranceCategory code) { 180 return code.getSystem(); 181 } 182 } 183 184 public enum AllergyIntoleranceCriticality { 185 /** 186 * Worst case result of a future exposure is not assessed to be life-threatening or having high potential for organ system failure. 187 */ 188 LOW, 189 /** 190 * Worst case result of a future exposure is assessed to be life-threatening or having high potential for organ system failure. 191 */ 192 HIGH, 193 /** 194 * Unable to assess the worst case result of a future exposure. 195 */ 196 UNABLETOASSESS, 197 /** 198 * added to help the parsers with the generic types 199 */ 200 NULL; 201 public static AllergyIntoleranceCriticality fromCode(String codeString) throws FHIRException { 202 if (codeString == null || "".equals(codeString)) 203 return null; 204 if ("low".equals(codeString)) 205 return LOW; 206 if ("high".equals(codeString)) 207 return HIGH; 208 if ("unable-to-assess".equals(codeString)) 209 return UNABLETOASSESS; 210 if (Configuration.isAcceptInvalidEnums()) 211 return null; 212 else 213 throw new FHIRException("Unknown AllergyIntoleranceCriticality code '"+codeString+"'"); 214 } 215 public String toCode() { 216 switch (this) { 217 case LOW: return "low"; 218 case HIGH: return "high"; 219 case UNABLETOASSESS: return "unable-to-assess"; 220 case NULL: return null; 221 default: return "?"; 222 } 223 } 224 public String getSystem() { 225 switch (this) { 226 case LOW: return "http://hl7.org/fhir/allergy-intolerance-criticality"; 227 case HIGH: return "http://hl7.org/fhir/allergy-intolerance-criticality"; 228 case UNABLETOASSESS: return "http://hl7.org/fhir/allergy-intolerance-criticality"; 229 case NULL: return null; 230 default: return "?"; 231 } 232 } 233 public String getDefinition() { 234 switch (this) { 235 case LOW: return "Worst case result of a future exposure is not assessed to be life-threatening or having high potential for organ system failure."; 236 case HIGH: return "Worst case result of a future exposure is assessed to be life-threatening or having high potential for organ system failure."; 237 case UNABLETOASSESS: return "Unable to assess the worst case result of a future exposure."; 238 case NULL: return null; 239 default: return "?"; 240 } 241 } 242 public String getDisplay() { 243 switch (this) { 244 case LOW: return "Low Risk"; 245 case HIGH: return "High Risk"; 246 case UNABLETOASSESS: return "Unable to Assess Risk"; 247 case NULL: return null; 248 default: return "?"; 249 } 250 } 251 } 252 253 public static class AllergyIntoleranceCriticalityEnumFactory implements EnumFactory<AllergyIntoleranceCriticality> { 254 public AllergyIntoleranceCriticality fromCode(String codeString) throws IllegalArgumentException { 255 if (codeString == null || "".equals(codeString)) 256 if (codeString == null || "".equals(codeString)) 257 return null; 258 if ("low".equals(codeString)) 259 return AllergyIntoleranceCriticality.LOW; 260 if ("high".equals(codeString)) 261 return AllergyIntoleranceCriticality.HIGH; 262 if ("unable-to-assess".equals(codeString)) 263 return AllergyIntoleranceCriticality.UNABLETOASSESS; 264 throw new IllegalArgumentException("Unknown AllergyIntoleranceCriticality code '"+codeString+"'"); 265 } 266 public Enumeration<AllergyIntoleranceCriticality> fromType(Base code) throws FHIRException { 267 if (code == null) 268 return null; 269 if (code.isEmpty()) 270 return new Enumeration<AllergyIntoleranceCriticality>(this); 271 String codeString = ((PrimitiveType) code).asStringValue(); 272 if (codeString == null || "".equals(codeString)) 273 return null; 274 if ("low".equals(codeString)) 275 return new Enumeration<AllergyIntoleranceCriticality>(this, AllergyIntoleranceCriticality.LOW); 276 if ("high".equals(codeString)) 277 return new Enumeration<AllergyIntoleranceCriticality>(this, AllergyIntoleranceCriticality.HIGH); 278 if ("unable-to-assess".equals(codeString)) 279 return new Enumeration<AllergyIntoleranceCriticality>(this, AllergyIntoleranceCriticality.UNABLETOASSESS); 280 throw new FHIRException("Unknown AllergyIntoleranceCriticality code '"+codeString+"'"); 281 } 282 public String toCode(AllergyIntoleranceCriticality code) { 283 if (code == AllergyIntoleranceCriticality.LOW) 284 return "low"; 285 if (code == AllergyIntoleranceCriticality.HIGH) 286 return "high"; 287 if (code == AllergyIntoleranceCriticality.UNABLETOASSESS) 288 return "unable-to-assess"; 289 return "?"; 290 } 291 public String toSystem(AllergyIntoleranceCriticality code) { 292 return code.getSystem(); 293 } 294 } 295 296 public enum AllergyIntoleranceSeverity { 297 /** 298 * Causes mild physiological effects. 299 */ 300 MILD, 301 /** 302 * Causes moderate physiological effects. 303 */ 304 MODERATE, 305 /** 306 * Causes severe physiological effects. 307 */ 308 SEVERE, 309 /** 310 * added to help the parsers with the generic types 311 */ 312 NULL; 313 public static AllergyIntoleranceSeverity fromCode(String codeString) throws FHIRException { 314 if (codeString == null || "".equals(codeString)) 315 return null; 316 if ("mild".equals(codeString)) 317 return MILD; 318 if ("moderate".equals(codeString)) 319 return MODERATE; 320 if ("severe".equals(codeString)) 321 return SEVERE; 322 if (Configuration.isAcceptInvalidEnums()) 323 return null; 324 else 325 throw new FHIRException("Unknown AllergyIntoleranceSeverity code '"+codeString+"'"); 326 } 327 public String toCode() { 328 switch (this) { 329 case MILD: return "mild"; 330 case MODERATE: return "moderate"; 331 case SEVERE: return "severe"; 332 case NULL: return null; 333 default: return "?"; 334 } 335 } 336 public String getSystem() { 337 switch (this) { 338 case MILD: return "http://hl7.org/fhir/reaction-event-severity"; 339 case MODERATE: return "http://hl7.org/fhir/reaction-event-severity"; 340 case SEVERE: return "http://hl7.org/fhir/reaction-event-severity"; 341 case NULL: return null; 342 default: return "?"; 343 } 344 } 345 public String getDefinition() { 346 switch (this) { 347 case MILD: return "Causes mild physiological effects."; 348 case MODERATE: return "Causes moderate physiological effects."; 349 case SEVERE: return "Causes severe physiological effects."; 350 case NULL: return null; 351 default: return "?"; 352 } 353 } 354 public String getDisplay() { 355 switch (this) { 356 case MILD: return "Mild"; 357 case MODERATE: return "Moderate"; 358 case SEVERE: return "Severe"; 359 case NULL: return null; 360 default: return "?"; 361 } 362 } 363 } 364 365 public static class AllergyIntoleranceSeverityEnumFactory implements EnumFactory<AllergyIntoleranceSeverity> { 366 public AllergyIntoleranceSeverity fromCode(String codeString) throws IllegalArgumentException { 367 if (codeString == null || "".equals(codeString)) 368 if (codeString == null || "".equals(codeString)) 369 return null; 370 if ("mild".equals(codeString)) 371 return AllergyIntoleranceSeverity.MILD; 372 if ("moderate".equals(codeString)) 373 return AllergyIntoleranceSeverity.MODERATE; 374 if ("severe".equals(codeString)) 375 return AllergyIntoleranceSeverity.SEVERE; 376 throw new IllegalArgumentException("Unknown AllergyIntoleranceSeverity code '"+codeString+"'"); 377 } 378 public Enumeration<AllergyIntoleranceSeverity> fromType(Base code) throws FHIRException { 379 if (code == null) 380 return null; 381 if (code.isEmpty()) 382 return new Enumeration<AllergyIntoleranceSeverity>(this); 383 String codeString = ((PrimitiveType) code).asStringValue(); 384 if (codeString == null || "".equals(codeString)) 385 return null; 386 if ("mild".equals(codeString)) 387 return new Enumeration<AllergyIntoleranceSeverity>(this, AllergyIntoleranceSeverity.MILD); 388 if ("moderate".equals(codeString)) 389 return new Enumeration<AllergyIntoleranceSeverity>(this, AllergyIntoleranceSeverity.MODERATE); 390 if ("severe".equals(codeString)) 391 return new Enumeration<AllergyIntoleranceSeverity>(this, AllergyIntoleranceSeverity.SEVERE); 392 throw new FHIRException("Unknown AllergyIntoleranceSeverity code '"+codeString+"'"); 393 } 394 public String toCode(AllergyIntoleranceSeverity code) { 395 if (code == AllergyIntoleranceSeverity.MILD) 396 return "mild"; 397 if (code == AllergyIntoleranceSeverity.MODERATE) 398 return "moderate"; 399 if (code == AllergyIntoleranceSeverity.SEVERE) 400 return "severe"; 401 return "?"; 402 } 403 public String toSystem(AllergyIntoleranceSeverity code) { 404 return code.getSystem(); 405 } 406 } 407 408 public enum AllergyIntoleranceType { 409 /** 410 * A propensity for hypersensitive reaction(s) to a substance. These reactions are most typically type I hypersensitivity, plus other \"allergy-like\" reactions, including pseudoallergy. 411 */ 412 ALLERGY, 413 /** 414 * A propensity for adverse reactions to a substance that is not judged to be allergic or \"allergy-like\". These reactions are typically (but not necessarily) non-immune. They are to some degree idiosyncratic and/or patient-specific (i.e. are not a reaction that is expected to occur with most or all patients given similar circumstances). 415 */ 416 INTOLERANCE, 417 /** 418 * added to help the parsers with the generic types 419 */ 420 NULL; 421 public static AllergyIntoleranceType fromCode(String codeString) throws FHIRException { 422 if (codeString == null || "".equals(codeString)) 423 return null; 424 if ("allergy".equals(codeString)) 425 return ALLERGY; 426 if ("intolerance".equals(codeString)) 427 return INTOLERANCE; 428 if (Configuration.isAcceptInvalidEnums()) 429 return null; 430 else 431 throw new FHIRException("Unknown AllergyIntoleranceType code '"+codeString+"'"); 432 } 433 public String toCode() { 434 switch (this) { 435 case ALLERGY: return "allergy"; 436 case INTOLERANCE: return "intolerance"; 437 case NULL: return null; 438 default: return "?"; 439 } 440 } 441 public String getSystem() { 442 switch (this) { 443 case ALLERGY: return "http://hl7.org/fhir/allergy-intolerance-type"; 444 case INTOLERANCE: return "http://hl7.org/fhir/allergy-intolerance-type"; 445 case NULL: return null; 446 default: return "?"; 447 } 448 } 449 public String getDefinition() { 450 switch (this) { 451 case ALLERGY: return "A propensity for hypersensitive reaction(s) to a substance. These reactions are most typically type I hypersensitivity, plus other \"allergy-like\" reactions, including pseudoallergy."; 452 case INTOLERANCE: return "A propensity for adverse reactions to a substance that is not judged to be allergic or \"allergy-like\". These reactions are typically (but not necessarily) non-immune. They are to some degree idiosyncratic and/or patient-specific (i.e. are not a reaction that is expected to occur with most or all patients given similar circumstances)."; 453 case NULL: return null; 454 default: return "?"; 455 } 456 } 457 public String getDisplay() { 458 switch (this) { 459 case ALLERGY: return "Allergy"; 460 case INTOLERANCE: return "Intolerance"; 461 case NULL: return null; 462 default: return "?"; 463 } 464 } 465 } 466 467 public static class AllergyIntoleranceTypeEnumFactory implements EnumFactory<AllergyIntoleranceType> { 468 public AllergyIntoleranceType fromCode(String codeString) throws IllegalArgumentException { 469 if (codeString == null || "".equals(codeString)) 470 if (codeString == null || "".equals(codeString)) 471 return null; 472 if ("allergy".equals(codeString)) 473 return AllergyIntoleranceType.ALLERGY; 474 if ("intolerance".equals(codeString)) 475 return AllergyIntoleranceType.INTOLERANCE; 476 throw new IllegalArgumentException("Unknown AllergyIntoleranceType code '"+codeString+"'"); 477 } 478 public Enumeration<AllergyIntoleranceType> fromType(Base code) throws FHIRException { 479 if (code == null) 480 return null; 481 if (code.isEmpty()) 482 return new Enumeration<AllergyIntoleranceType>(this); 483 String codeString = ((PrimitiveType) code).asStringValue(); 484 if (codeString == null || "".equals(codeString)) 485 return null; 486 if ("allergy".equals(codeString)) 487 return new Enumeration<AllergyIntoleranceType>(this, AllergyIntoleranceType.ALLERGY); 488 if ("intolerance".equals(codeString)) 489 return new Enumeration<AllergyIntoleranceType>(this, AllergyIntoleranceType.INTOLERANCE); 490 throw new FHIRException("Unknown AllergyIntoleranceType code '"+codeString+"'"); 491 } 492 public String toCode(AllergyIntoleranceType code) { 493 if (code == AllergyIntoleranceType.ALLERGY) 494 return "allergy"; 495 if (code == AllergyIntoleranceType.INTOLERANCE) 496 return "intolerance"; 497 return "?"; 498 } 499 public String toSystem(AllergyIntoleranceType code) { 500 return code.getSystem(); 501 } 502 } 503 504 @Block() 505 public static class AllergyIntoleranceReactionComponent extends BackboneElement implements IBaseBackboneElement { 506 /** 507 * Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance. 508 */ 509 @Child(name = "substance", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false) 510 @Description(shortDefinition="Specific substance or pharmaceutical product considered to be responsible for event", formalDefinition="Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance." ) 511 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/substance-code") 512 protected CodeableConcept substance; 513 514 /** 515 * Clinical symptoms and/or signs that are observed or associated with the adverse reaction event. 516 */ 517 @Child(name = "manifestation", type = {CodeableConcept.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 518 @Description(shortDefinition="Clinical symptoms/signs associated with the Event", formalDefinition="Clinical symptoms and/or signs that are observed or associated with the adverse reaction event." ) 519 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/clinical-findings") 520 protected List<CodeableConcept> manifestation; 521 522 /** 523 * Text description about the reaction as a whole, including details of the manifestation if required. 524 */ 525 @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false) 526 @Description(shortDefinition="Description of the event as a whole", formalDefinition="Text description about the reaction as a whole, including details of the manifestation if required." ) 527 protected StringType description; 528 529 /** 530 * Record of the date and/or time of the onset of the Reaction. 531 */ 532 @Child(name = "onset", type = {DateTimeType.class}, order=4, min=0, max=1, modifier=false, summary=false) 533 @Description(shortDefinition="Date(/time) when manifestations showed", formalDefinition="Record of the date and/or time of the onset of the Reaction." ) 534 protected DateTimeType onset; 535 536 /** 537 * Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations. 538 */ 539 @Child(name = "severity", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=false) 540 @Description(shortDefinition="mild | moderate | severe (of event as a whole)", formalDefinition="Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations." ) 541 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reaction-event-severity") 542 protected Enumeration<AllergyIntoleranceSeverity> severity; 543 544 /** 545 * Identification of the route by which the subject was exposed to the substance. 546 */ 547 @Child(name = "exposureRoute", type = {CodeableConcept.class}, order=6, min=0, max=1, modifier=false, summary=false) 548 @Description(shortDefinition="How the subject was exposed to the substance", formalDefinition="Identification of the route by which the subject was exposed to the substance." ) 549 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/route-codes") 550 protected CodeableConcept exposureRoute; 551 552 /** 553 * Additional text about the adverse reaction event not captured in other fields. 554 */ 555 @Child(name = "note", type = {Annotation.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 556 @Description(shortDefinition="Text about event not captured in other fields", formalDefinition="Additional text about the adverse reaction event not captured in other fields." ) 557 protected List<Annotation> note; 558 559 private static final long serialVersionUID = -752118516L; 560 561 /** 562 * Constructor 563 */ 564 public AllergyIntoleranceReactionComponent() { 565 super(); 566 } 567 568 /** 569 * Constructor 570 */ 571 public AllergyIntoleranceReactionComponent(CodeableConcept manifestation) { 572 super(); 573 this.addManifestation(manifestation); 574 } 575 576 /** 577 * @return {@link #substance} (Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.) 578 */ 579 public CodeableConcept getSubstance() { 580 if (this.substance == null) 581 if (Configuration.errorOnAutoCreate()) 582 throw new Error("Attempt to auto-create AllergyIntoleranceReactionComponent.substance"); 583 else if (Configuration.doAutoCreate()) 584 this.substance = new CodeableConcept(); // cc 585 return this.substance; 586 } 587 588 public boolean hasSubstance() { 589 return this.substance != null && !this.substance.isEmpty(); 590 } 591 592 /** 593 * @param value {@link #substance} (Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.) 594 */ 595 public AllergyIntoleranceReactionComponent setSubstance(CodeableConcept value) { 596 this.substance = value; 597 return this; 598 } 599 600 /** 601 * @return {@link #manifestation} (Clinical symptoms and/or signs that are observed or associated with the adverse reaction event.) 602 */ 603 public List<CodeableConcept> getManifestation() { 604 if (this.manifestation == null) 605 this.manifestation = new ArrayList<CodeableConcept>(); 606 return this.manifestation; 607 } 608 609 /** 610 * @return Returns a reference to <code>this</code> for easy method chaining 611 */ 612 public AllergyIntoleranceReactionComponent setManifestation(List<CodeableConcept> theManifestation) { 613 this.manifestation = theManifestation; 614 return this; 615 } 616 617 public boolean hasManifestation() { 618 if (this.manifestation == null) 619 return false; 620 for (CodeableConcept item : this.manifestation) 621 if (!item.isEmpty()) 622 return true; 623 return false; 624 } 625 626 public CodeableConcept addManifestation() { //3 627 CodeableConcept t = new CodeableConcept(); 628 if (this.manifestation == null) 629 this.manifestation = new ArrayList<CodeableConcept>(); 630 this.manifestation.add(t); 631 return t; 632 } 633 634 public AllergyIntoleranceReactionComponent addManifestation(CodeableConcept t) { //3 635 if (t == null) 636 return this; 637 if (this.manifestation == null) 638 this.manifestation = new ArrayList<CodeableConcept>(); 639 this.manifestation.add(t); 640 return this; 641 } 642 643 /** 644 * @return The first repetition of repeating field {@link #manifestation}, creating it if it does not already exist {3} 645 */ 646 public CodeableConcept getManifestationFirstRep() { 647 if (getManifestation().isEmpty()) { 648 addManifestation(); 649 } 650 return getManifestation().get(0); 651 } 652 653 /** 654 * @return {@link #description} (Text description about the reaction as a whole, including details of the manifestation if required.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 655 */ 656 public StringType getDescriptionElement() { 657 if (this.description == null) 658 if (Configuration.errorOnAutoCreate()) 659 throw new Error("Attempt to auto-create AllergyIntoleranceReactionComponent.description"); 660 else if (Configuration.doAutoCreate()) 661 this.description = new StringType(); // bb 662 return this.description; 663 } 664 665 public boolean hasDescriptionElement() { 666 return this.description != null && !this.description.isEmpty(); 667 } 668 669 public boolean hasDescription() { 670 return this.description != null && !this.description.isEmpty(); 671 } 672 673 /** 674 * @param value {@link #description} (Text description about the reaction as a whole, including details of the manifestation if required.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 675 */ 676 public AllergyIntoleranceReactionComponent setDescriptionElement(StringType value) { 677 this.description = value; 678 return this; 679 } 680 681 /** 682 * @return Text description about the reaction as a whole, including details of the manifestation if required. 683 */ 684 public String getDescription() { 685 return this.description == null ? null : this.description.getValue(); 686 } 687 688 /** 689 * @param value Text description about the reaction as a whole, including details of the manifestation if required. 690 */ 691 public AllergyIntoleranceReactionComponent setDescription(String value) { 692 if (Utilities.noString(value)) 693 this.description = null; 694 else { 695 if (this.description == null) 696 this.description = new StringType(); 697 this.description.setValue(value); 698 } 699 return this; 700 } 701 702 /** 703 * @return {@link #onset} (Record of the date and/or time of the onset of the Reaction.). This is the underlying object with id, value and extensions. The accessor "getOnset" gives direct access to the value 704 */ 705 public DateTimeType getOnsetElement() { 706 if (this.onset == null) 707 if (Configuration.errorOnAutoCreate()) 708 throw new Error("Attempt to auto-create AllergyIntoleranceReactionComponent.onset"); 709 else if (Configuration.doAutoCreate()) 710 this.onset = new DateTimeType(); // bb 711 return this.onset; 712 } 713 714 public boolean hasOnsetElement() { 715 return this.onset != null && !this.onset.isEmpty(); 716 } 717 718 public boolean hasOnset() { 719 return this.onset != null && !this.onset.isEmpty(); 720 } 721 722 /** 723 * @param value {@link #onset} (Record of the date and/or time of the onset of the Reaction.). This is the underlying object with id, value and extensions. The accessor "getOnset" gives direct access to the value 724 */ 725 public AllergyIntoleranceReactionComponent setOnsetElement(DateTimeType value) { 726 this.onset = value; 727 return this; 728 } 729 730 /** 731 * @return Record of the date and/or time of the onset of the Reaction. 732 */ 733 public Date getOnset() { 734 return this.onset == null ? null : this.onset.getValue(); 735 } 736 737 /** 738 * @param value Record of the date and/or time of the onset of the Reaction. 739 */ 740 public AllergyIntoleranceReactionComponent setOnset(Date value) { 741 if (value == null) 742 this.onset = null; 743 else { 744 if (this.onset == null) 745 this.onset = new DateTimeType(); 746 this.onset.setValue(value); 747 } 748 return this; 749 } 750 751 /** 752 * @return {@link #severity} (Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value 753 */ 754 public Enumeration<AllergyIntoleranceSeverity> getSeverityElement() { 755 if (this.severity == null) 756 if (Configuration.errorOnAutoCreate()) 757 throw new Error("Attempt to auto-create AllergyIntoleranceReactionComponent.severity"); 758 else if (Configuration.doAutoCreate()) 759 this.severity = new Enumeration<AllergyIntoleranceSeverity>(new AllergyIntoleranceSeverityEnumFactory()); // bb 760 return this.severity; 761 } 762 763 public boolean hasSeverityElement() { 764 return this.severity != null && !this.severity.isEmpty(); 765 } 766 767 public boolean hasSeverity() { 768 return this.severity != null && !this.severity.isEmpty(); 769 } 770 771 /** 772 * @param value {@link #severity} (Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value 773 */ 774 public AllergyIntoleranceReactionComponent setSeverityElement(Enumeration<AllergyIntoleranceSeverity> value) { 775 this.severity = value; 776 return this; 777 } 778 779 /** 780 * @return Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations. 781 */ 782 public AllergyIntoleranceSeverity getSeverity() { 783 return this.severity == null ? null : this.severity.getValue(); 784 } 785 786 /** 787 * @param value Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations. 788 */ 789 public AllergyIntoleranceReactionComponent setSeverity(AllergyIntoleranceSeverity value) { 790 if (value == null) 791 this.severity = null; 792 else { 793 if (this.severity == null) 794 this.severity = new Enumeration<AllergyIntoleranceSeverity>(new AllergyIntoleranceSeverityEnumFactory()); 795 this.severity.setValue(value); 796 } 797 return this; 798 } 799 800 /** 801 * @return {@link #exposureRoute} (Identification of the route by which the subject was exposed to the substance.) 802 */ 803 public CodeableConcept getExposureRoute() { 804 if (this.exposureRoute == null) 805 if (Configuration.errorOnAutoCreate()) 806 throw new Error("Attempt to auto-create AllergyIntoleranceReactionComponent.exposureRoute"); 807 else if (Configuration.doAutoCreate()) 808 this.exposureRoute = new CodeableConcept(); // cc 809 return this.exposureRoute; 810 } 811 812 public boolean hasExposureRoute() { 813 return this.exposureRoute != null && !this.exposureRoute.isEmpty(); 814 } 815 816 /** 817 * @param value {@link #exposureRoute} (Identification of the route by which the subject was exposed to the substance.) 818 */ 819 public AllergyIntoleranceReactionComponent setExposureRoute(CodeableConcept value) { 820 this.exposureRoute = value; 821 return this; 822 } 823 824 /** 825 * @return {@link #note} (Additional text about the adverse reaction event not captured in other fields.) 826 */ 827 public List<Annotation> getNote() { 828 if (this.note == null) 829 this.note = new ArrayList<Annotation>(); 830 return this.note; 831 } 832 833 /** 834 * @return Returns a reference to <code>this</code> for easy method chaining 835 */ 836 public AllergyIntoleranceReactionComponent setNote(List<Annotation> theNote) { 837 this.note = theNote; 838 return this; 839 } 840 841 public boolean hasNote() { 842 if (this.note == null) 843 return false; 844 for (Annotation item : this.note) 845 if (!item.isEmpty()) 846 return true; 847 return false; 848 } 849 850 public Annotation addNote() { //3 851 Annotation t = new Annotation(); 852 if (this.note == null) 853 this.note = new ArrayList<Annotation>(); 854 this.note.add(t); 855 return t; 856 } 857 858 public AllergyIntoleranceReactionComponent addNote(Annotation t) { //3 859 if (t == null) 860 return this; 861 if (this.note == null) 862 this.note = new ArrayList<Annotation>(); 863 this.note.add(t); 864 return this; 865 } 866 867 /** 868 * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist {3} 869 */ 870 public Annotation getNoteFirstRep() { 871 if (getNote().isEmpty()) { 872 addNote(); 873 } 874 return getNote().get(0); 875 } 876 877 protected void listChildren(List<Property> children) { 878 super.listChildren(children); 879 children.add(new Property("substance", "CodeableConcept", "Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.", 0, 1, substance)); 880 children.add(new Property("manifestation", "CodeableConcept", "Clinical symptoms and/or signs that are observed or associated with the adverse reaction event.", 0, java.lang.Integer.MAX_VALUE, manifestation)); 881 children.add(new Property("description", "string", "Text description about the reaction as a whole, including details of the manifestation if required.", 0, 1, description)); 882 children.add(new Property("onset", "dateTime", "Record of the date and/or time of the onset of the Reaction.", 0, 1, onset)); 883 children.add(new Property("severity", "code", "Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations.", 0, 1, severity)); 884 children.add(new Property("exposureRoute", "CodeableConcept", "Identification of the route by which the subject was exposed to the substance.", 0, 1, exposureRoute)); 885 children.add(new Property("note", "Annotation", "Additional text about the adverse reaction event not captured in other fields.", 0, java.lang.Integer.MAX_VALUE, note)); 886 } 887 888 @Override 889 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 890 switch (_hash) { 891 case 530040176: /*substance*/ return new Property("substance", "CodeableConcept", "Identification of the specific substance (or pharmaceutical product) considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.", 0, 1, substance); 892 case 1115984422: /*manifestation*/ return new Property("manifestation", "CodeableConcept", "Clinical symptoms and/or signs that are observed or associated with the adverse reaction event.", 0, java.lang.Integer.MAX_VALUE, manifestation); 893 case -1724546052: /*description*/ return new Property("description", "string", "Text description about the reaction as a whole, including details of the manifestation if required.", 0, 1, description); 894 case 105901603: /*onset*/ return new Property("onset", "dateTime", "Record of the date and/or time of the onset of the Reaction.", 0, 1, onset); 895 case 1478300413: /*severity*/ return new Property("severity", "code", "Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations.", 0, 1, severity); 896 case 421286274: /*exposureRoute*/ return new Property("exposureRoute", "CodeableConcept", "Identification of the route by which the subject was exposed to the substance.", 0, 1, exposureRoute); 897 case 3387378: /*note*/ return new Property("note", "Annotation", "Additional text about the adverse reaction event not captured in other fields.", 0, java.lang.Integer.MAX_VALUE, note); 898 default: return super.getNamedProperty(_hash, _name, _checkValid); 899 } 900 901 } 902 903 @Override 904 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 905 switch (hash) { 906 case 530040176: /*substance*/ return this.substance == null ? new Base[0] : new Base[] {this.substance}; // CodeableConcept 907 case 1115984422: /*manifestation*/ return this.manifestation == null ? new Base[0] : this.manifestation.toArray(new Base[this.manifestation.size()]); // CodeableConcept 908 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 909 case 105901603: /*onset*/ return this.onset == null ? new Base[0] : new Base[] {this.onset}; // DateTimeType 910 case 1478300413: /*severity*/ return this.severity == null ? new Base[0] : new Base[] {this.severity}; // Enumeration<AllergyIntoleranceSeverity> 911 case 421286274: /*exposureRoute*/ return this.exposureRoute == null ? new Base[0] : new Base[] {this.exposureRoute}; // CodeableConcept 912 case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 913 default: return super.getProperty(hash, name, checkValid); 914 } 915 916 } 917 918 @Override 919 public Base setProperty(int hash, String name, Base value) throws FHIRException { 920 switch (hash) { 921 case 530040176: // substance 922 this.substance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 923 return value; 924 case 1115984422: // manifestation 925 this.getManifestation().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept 926 return value; 927 case -1724546052: // description 928 this.description = TypeConvertor.castToString(value); // StringType 929 return value; 930 case 105901603: // onset 931 this.onset = TypeConvertor.castToDateTime(value); // DateTimeType 932 return value; 933 case 1478300413: // severity 934 value = new AllergyIntoleranceSeverityEnumFactory().fromType(TypeConvertor.castToCode(value)); 935 this.severity = (Enumeration) value; // Enumeration<AllergyIntoleranceSeverity> 936 return value; 937 case 421286274: // exposureRoute 938 this.exposureRoute = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 939 return value; 940 case 3387378: // note 941 this.getNote().add(TypeConvertor.castToAnnotation(value)); // Annotation 942 return value; 943 default: return super.setProperty(hash, name, value); 944 } 945 946 } 947 948 @Override 949 public Base setProperty(String name, Base value) throws FHIRException { 950 if (name.equals("substance")) { 951 this.substance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 952 } else if (name.equals("manifestation")) { 953 this.getManifestation().add(TypeConvertor.castToCodeableConcept(value)); 954 } else if (name.equals("description")) { 955 this.description = TypeConvertor.castToString(value); // StringType 956 } else if (name.equals("onset")) { 957 this.onset = TypeConvertor.castToDateTime(value); // DateTimeType 958 } else if (name.equals("severity")) { 959 value = new AllergyIntoleranceSeverityEnumFactory().fromType(TypeConvertor.castToCode(value)); 960 this.severity = (Enumeration) value; // Enumeration<AllergyIntoleranceSeverity> 961 } else if (name.equals("exposureRoute")) { 962 this.exposureRoute = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 963 } else if (name.equals("note")) { 964 this.getNote().add(TypeConvertor.castToAnnotation(value)); 965 } else 966 return super.setProperty(name, value); 967 return value; 968 } 969 970 @Override 971 public Base makeProperty(int hash, String name) throws FHIRException { 972 switch (hash) { 973 case 530040176: return getSubstance(); 974 case 1115984422: return addManifestation(); 975 case -1724546052: return getDescriptionElement(); 976 case 105901603: return getOnsetElement(); 977 case 1478300413: return getSeverityElement(); 978 case 421286274: return getExposureRoute(); 979 case 3387378: return addNote(); 980 default: return super.makeProperty(hash, name); 981 } 982 983 } 984 985 @Override 986 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 987 switch (hash) { 988 case 530040176: /*substance*/ return new String[] {"CodeableConcept"}; 989 case 1115984422: /*manifestation*/ return new String[] {"CodeableConcept"}; 990 case -1724546052: /*description*/ return new String[] {"string"}; 991 case 105901603: /*onset*/ return new String[] {"dateTime"}; 992 case 1478300413: /*severity*/ return new String[] {"code"}; 993 case 421286274: /*exposureRoute*/ return new String[] {"CodeableConcept"}; 994 case 3387378: /*note*/ return new String[] {"Annotation"}; 995 default: return super.getTypesForProperty(hash, name); 996 } 997 998 } 999 1000 @Override 1001 public Base addChild(String name) throws FHIRException { 1002 if (name.equals("substance")) { 1003 this.substance = new CodeableConcept(); 1004 return this.substance; 1005 } 1006 else if (name.equals("manifestation")) { 1007 return addManifestation(); 1008 } 1009 else if (name.equals("description")) { 1010 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.reaction.description"); 1011 } 1012 else if (name.equals("onset")) { 1013 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.reaction.onset"); 1014 } 1015 else if (name.equals("severity")) { 1016 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.reaction.severity"); 1017 } 1018 else if (name.equals("exposureRoute")) { 1019 this.exposureRoute = new CodeableConcept(); 1020 return this.exposureRoute; 1021 } 1022 else if (name.equals("note")) { 1023 return addNote(); 1024 } 1025 else 1026 return super.addChild(name); 1027 } 1028 1029 public AllergyIntoleranceReactionComponent copy() { 1030 AllergyIntoleranceReactionComponent dst = new AllergyIntoleranceReactionComponent(); 1031 copyValues(dst); 1032 return dst; 1033 } 1034 1035 public void copyValues(AllergyIntoleranceReactionComponent dst) { 1036 super.copyValues(dst); 1037 dst.substance = substance == null ? null : substance.copy(); 1038 if (manifestation != null) { 1039 dst.manifestation = new ArrayList<CodeableConcept>(); 1040 for (CodeableConcept i : manifestation) 1041 dst.manifestation.add(i.copy()); 1042 }; 1043 dst.description = description == null ? null : description.copy(); 1044 dst.onset = onset == null ? null : onset.copy(); 1045 dst.severity = severity == null ? null : severity.copy(); 1046 dst.exposureRoute = exposureRoute == null ? null : exposureRoute.copy(); 1047 if (note != null) { 1048 dst.note = new ArrayList<Annotation>(); 1049 for (Annotation i : note) 1050 dst.note.add(i.copy()); 1051 }; 1052 } 1053 1054 @Override 1055 public boolean equalsDeep(Base other_) { 1056 if (!super.equalsDeep(other_)) 1057 return false; 1058 if (!(other_ instanceof AllergyIntoleranceReactionComponent)) 1059 return false; 1060 AllergyIntoleranceReactionComponent o = (AllergyIntoleranceReactionComponent) other_; 1061 return compareDeep(substance, o.substance, true) && compareDeep(manifestation, o.manifestation, true) 1062 && compareDeep(description, o.description, true) && compareDeep(onset, o.onset, true) && compareDeep(severity, o.severity, true) 1063 && compareDeep(exposureRoute, o.exposureRoute, true) && compareDeep(note, o.note, true); 1064 } 1065 1066 @Override 1067 public boolean equalsShallow(Base other_) { 1068 if (!super.equalsShallow(other_)) 1069 return false; 1070 if (!(other_ instanceof AllergyIntoleranceReactionComponent)) 1071 return false; 1072 AllergyIntoleranceReactionComponent o = (AllergyIntoleranceReactionComponent) other_; 1073 return compareValues(description, o.description, true) && compareValues(onset, o.onset, true) && compareValues(severity, o.severity, true) 1074 ; 1075 } 1076 1077 public boolean isEmpty() { 1078 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(substance, manifestation, description 1079 , onset, severity, exposureRoute, note); 1080 } 1081 1082 public String fhirType() { 1083 return "AllergyIntolerance.reaction"; 1084 1085 } 1086 1087 } 1088 1089 /** 1090 * Business identifiers assigned to this AllergyIntolerance by the performer or other systems which remain constant as the resource is updated and propagates from server to server. 1091 */ 1092 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1093 @Description(shortDefinition="External ids for this item", formalDefinition="Business identifiers assigned to this AllergyIntolerance by the performer or other systems which remain constant as the resource is updated and propagates from server to server." ) 1094 protected List<Identifier> identifier; 1095 1096 /** 1097 * The clinical status of the allergy or intolerance. 1098 */ 1099 @Child(name = "clinicalStatus", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=true, summary=true) 1100 @Description(shortDefinition="active | inactive | resolved", formalDefinition="The clinical status of the allergy or intolerance." ) 1101 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergyintolerance-clinical") 1102 protected CodeableConcept clinicalStatus; 1103 1104 /** 1105 * Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product). 1106 */ 1107 @Child(name = "verificationStatus", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=true, summary=true) 1108 @Description(shortDefinition="unconfirmed | confirmed | refuted | entered-in-error", formalDefinition="Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product)." ) 1109 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergyintolerance-verification") 1110 protected CodeableConcept verificationStatus; 1111 1112 /** 1113 * Identification of the underlying physiological mechanism for the reaction risk. 1114 */ 1115 @Child(name = "type", type = {CodeType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1116 @Description(shortDefinition="allergy | intolerance - Underlying mechanism (if known)", formalDefinition="Identification of the underlying physiological mechanism for the reaction risk." ) 1117 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-type") 1118 protected Enumeration<AllergyIntoleranceType> type; 1119 1120 /** 1121 * Category of the identified substance. 1122 */ 1123 @Child(name = "category", type = {CodeType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1124 @Description(shortDefinition="food | medication | environment | biologic", formalDefinition="Category of the identified substance." ) 1125 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-category") 1126 protected List<Enumeration<AllergyIntoleranceCategory>> category; 1127 1128 /** 1129 * Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance. 1130 */ 1131 @Child(name = "criticality", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=true) 1132 @Description(shortDefinition="low | high | unable-to-assess", formalDefinition="Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance." ) 1133 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-criticality") 1134 protected Enumeration<AllergyIntoleranceCriticality> criticality; 1135 1136 /** 1137 * Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., "Latex"), an allergy or intolerance condition (e.g., "Latex allergy"), or a negated/excluded code for a specific substance or class (e.g., "No latex allergy") or a general or categorical negated statement (e.g., "No known allergy", "No known drug allergies"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance. 1138 */ 1139 @Child(name = "code", type = {CodeableConcept.class}, order=6, min=0, max=1, modifier=false, summary=true) 1140 @Description(shortDefinition="Code that identifies the allergy or intolerance", formalDefinition="Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., \"Latex\"), an allergy or intolerance condition (e.g., \"Latex allergy\"), or a negated/excluded code for a specific substance or class (e.g., \"No latex allergy\") or a general or categorical negated statement (e.g., \"No known allergy\", \"No known drug allergies\"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance." ) 1141 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergyintolerance-code") 1142 protected CodeableConcept code; 1143 1144 /** 1145 * The patient who has the allergy or intolerance. 1146 */ 1147 @Child(name = "patient", type = {Patient.class}, order=7, min=1, max=1, modifier=false, summary=true) 1148 @Description(shortDefinition="Who the sensitivity is for", formalDefinition="The patient who has the allergy or intolerance." ) 1149 protected Reference patient; 1150 1151 /** 1152 * The encounter when the allergy or intolerance was asserted. 1153 */ 1154 @Child(name = "encounter", type = {Encounter.class}, order=8, min=0, max=1, modifier=false, summary=false) 1155 @Description(shortDefinition="Encounter when the allergy or intolerance was asserted", formalDefinition="The encounter when the allergy or intolerance was asserted." ) 1156 protected Reference encounter; 1157 1158 /** 1159 * Estimated or actual date, date-time, or age when allergy or intolerance was identified. 1160 */ 1161 @Child(name = "onset", type = {DateTimeType.class, Age.class, Period.class, Range.class, StringType.class}, order=9, min=0, max=1, modifier=false, summary=false) 1162 @Description(shortDefinition="When allergy or intolerance was identified", formalDefinition="Estimated or actual date, date-time, or age when allergy or intolerance was identified." ) 1163 protected DataType onset; 1164 1165 /** 1166 * The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date. 1167 */ 1168 @Child(name = "recordedDate", type = {DateTimeType.class}, order=10, min=0, max=1, modifier=false, summary=false) 1169 @Description(shortDefinition="Date first version of the resource instance was recorded", formalDefinition="The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date." ) 1170 protected DateTimeType recordedDate; 1171 1172 /** 1173 * Individual who recorded the record and takes responsibility for its content. 1174 */ 1175 @Child(name = "recorder", type = {Practitioner.class, PractitionerRole.class, Patient.class, RelatedPerson.class}, order=11, min=0, max=1, modifier=false, summary=false) 1176 @Description(shortDefinition="Who recorded the sensitivity", formalDefinition="Individual who recorded the record and takes responsibility for its content." ) 1177 protected Reference recorder; 1178 1179 /** 1180 * The source of the information about the allergy that is recorded. 1181 */ 1182 @Child(name = "asserter", type = {Patient.class, RelatedPerson.class, Practitioner.class, PractitionerRole.class}, order=12, min=0, max=1, modifier=false, summary=true) 1183 @Description(shortDefinition="Source of the information about the allergy", formalDefinition="The source of the information about the allergy that is recorded." ) 1184 protected Reference asserter; 1185 1186 /** 1187 * Represents the date and/or time of the last known occurrence of a reaction event. 1188 */ 1189 @Child(name = "lastOccurrence", type = {DateTimeType.class}, order=13, min=0, max=1, modifier=false, summary=false) 1190 @Description(shortDefinition="Date(/time) of last known occurrence of a reaction", formalDefinition="Represents the date and/or time of the last known occurrence of a reaction event." ) 1191 protected DateTimeType lastOccurrence; 1192 1193 /** 1194 * Additional narrative about the propensity for the Adverse Reaction, not captured in other fields. 1195 */ 1196 @Child(name = "note", type = {Annotation.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1197 @Description(shortDefinition="Additional text not captured in other fields", formalDefinition="Additional narrative about the propensity for the Adverse Reaction, not captured in other fields." ) 1198 protected List<Annotation> note; 1199 1200 /** 1201 * Details about each adverse reaction event linked to exposure to the identified substance. 1202 */ 1203 @Child(name = "reaction", type = {}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1204 @Description(shortDefinition="Adverse Reaction Events linked to exposure to substance", formalDefinition="Details about each adverse reaction event linked to exposure to the identified substance." ) 1205 protected List<AllergyIntoleranceReactionComponent> reaction; 1206 1207 private static final long serialVersionUID = 1489554196L; 1208 1209 /** 1210 * Constructor 1211 */ 1212 public AllergyIntolerance() { 1213 super(); 1214 } 1215 1216 /** 1217 * Constructor 1218 */ 1219 public AllergyIntolerance(Reference patient) { 1220 super(); 1221 this.setPatient(patient); 1222 } 1223 1224 /** 1225 * @return {@link #identifier} (Business identifiers assigned to this AllergyIntolerance by the performer or other systems which remain constant as the resource is updated and propagates from server to server.) 1226 */ 1227 public List<Identifier> getIdentifier() { 1228 if (this.identifier == null) 1229 this.identifier = new ArrayList<Identifier>(); 1230 return this.identifier; 1231 } 1232 1233 /** 1234 * @return Returns a reference to <code>this</code> for easy method chaining 1235 */ 1236 public AllergyIntolerance setIdentifier(List<Identifier> theIdentifier) { 1237 this.identifier = theIdentifier; 1238 return this; 1239 } 1240 1241 public boolean hasIdentifier() { 1242 if (this.identifier == null) 1243 return false; 1244 for (Identifier item : this.identifier) 1245 if (!item.isEmpty()) 1246 return true; 1247 return false; 1248 } 1249 1250 public Identifier addIdentifier() { //3 1251 Identifier t = new Identifier(); 1252 if (this.identifier == null) 1253 this.identifier = new ArrayList<Identifier>(); 1254 this.identifier.add(t); 1255 return t; 1256 } 1257 1258 public AllergyIntolerance addIdentifier(Identifier t) { //3 1259 if (t == null) 1260 return this; 1261 if (this.identifier == null) 1262 this.identifier = new ArrayList<Identifier>(); 1263 this.identifier.add(t); 1264 return this; 1265 } 1266 1267 /** 1268 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3} 1269 */ 1270 public Identifier getIdentifierFirstRep() { 1271 if (getIdentifier().isEmpty()) { 1272 addIdentifier(); 1273 } 1274 return getIdentifier().get(0); 1275 } 1276 1277 /** 1278 * @return {@link #clinicalStatus} (The clinical status of the allergy or intolerance.) 1279 */ 1280 public CodeableConcept getClinicalStatus() { 1281 if (this.clinicalStatus == null) 1282 if (Configuration.errorOnAutoCreate()) 1283 throw new Error("Attempt to auto-create AllergyIntolerance.clinicalStatus"); 1284 else if (Configuration.doAutoCreate()) 1285 this.clinicalStatus = new CodeableConcept(); // cc 1286 return this.clinicalStatus; 1287 } 1288 1289 public boolean hasClinicalStatus() { 1290 return this.clinicalStatus != null && !this.clinicalStatus.isEmpty(); 1291 } 1292 1293 /** 1294 * @param value {@link #clinicalStatus} (The clinical status of the allergy or intolerance.) 1295 */ 1296 public AllergyIntolerance setClinicalStatus(CodeableConcept value) { 1297 this.clinicalStatus = value; 1298 return this; 1299 } 1300 1301 /** 1302 * @return {@link #verificationStatus} (Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product).) 1303 */ 1304 public CodeableConcept getVerificationStatus() { 1305 if (this.verificationStatus == null) 1306 if (Configuration.errorOnAutoCreate()) 1307 throw new Error("Attempt to auto-create AllergyIntolerance.verificationStatus"); 1308 else if (Configuration.doAutoCreate()) 1309 this.verificationStatus = new CodeableConcept(); // cc 1310 return this.verificationStatus; 1311 } 1312 1313 public boolean hasVerificationStatus() { 1314 return this.verificationStatus != null && !this.verificationStatus.isEmpty(); 1315 } 1316 1317 /** 1318 * @param value {@link #verificationStatus} (Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product).) 1319 */ 1320 public AllergyIntolerance setVerificationStatus(CodeableConcept value) { 1321 this.verificationStatus = value; 1322 return this; 1323 } 1324 1325 /** 1326 * @return {@link #type} (Identification of the underlying physiological mechanism for the reaction risk.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1327 */ 1328 public Enumeration<AllergyIntoleranceType> getTypeElement() { 1329 if (this.type == null) 1330 if (Configuration.errorOnAutoCreate()) 1331 throw new Error("Attempt to auto-create AllergyIntolerance.type"); 1332 else if (Configuration.doAutoCreate()) 1333 this.type = new Enumeration<AllergyIntoleranceType>(new AllergyIntoleranceTypeEnumFactory()); // bb 1334 return this.type; 1335 } 1336 1337 public boolean hasTypeElement() { 1338 return this.type != null && !this.type.isEmpty(); 1339 } 1340 1341 public boolean hasType() { 1342 return this.type != null && !this.type.isEmpty(); 1343 } 1344 1345 /** 1346 * @param value {@link #type} (Identification of the underlying physiological mechanism for the reaction risk.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1347 */ 1348 public AllergyIntolerance setTypeElement(Enumeration<AllergyIntoleranceType> value) { 1349 this.type = value; 1350 return this; 1351 } 1352 1353 /** 1354 * @return Identification of the underlying physiological mechanism for the reaction risk. 1355 */ 1356 public AllergyIntoleranceType getType() { 1357 return this.type == null ? null : this.type.getValue(); 1358 } 1359 1360 /** 1361 * @param value Identification of the underlying physiological mechanism for the reaction risk. 1362 */ 1363 public AllergyIntolerance setType(AllergyIntoleranceType value) { 1364 if (value == null) 1365 this.type = null; 1366 else { 1367 if (this.type == null) 1368 this.type = new Enumeration<AllergyIntoleranceType>(new AllergyIntoleranceTypeEnumFactory()); 1369 this.type.setValue(value); 1370 } 1371 return this; 1372 } 1373 1374 /** 1375 * @return {@link #category} (Category of the identified substance.) 1376 */ 1377 public List<Enumeration<AllergyIntoleranceCategory>> getCategory() { 1378 if (this.category == null) 1379 this.category = new ArrayList<Enumeration<AllergyIntoleranceCategory>>(); 1380 return this.category; 1381 } 1382 1383 /** 1384 * @return Returns a reference to <code>this</code> for easy method chaining 1385 */ 1386 public AllergyIntolerance setCategory(List<Enumeration<AllergyIntoleranceCategory>> theCategory) { 1387 this.category = theCategory; 1388 return this; 1389 } 1390 1391 public boolean hasCategory() { 1392 if (this.category == null) 1393 return false; 1394 for (Enumeration<AllergyIntoleranceCategory> item : this.category) 1395 if (!item.isEmpty()) 1396 return true; 1397 return false; 1398 } 1399 1400 /** 1401 * @return {@link #category} (Category of the identified substance.) 1402 */ 1403 public Enumeration<AllergyIntoleranceCategory> addCategoryElement() {//2 1404 Enumeration<AllergyIntoleranceCategory> t = new Enumeration<AllergyIntoleranceCategory>(new AllergyIntoleranceCategoryEnumFactory()); 1405 if (this.category == null) 1406 this.category = new ArrayList<Enumeration<AllergyIntoleranceCategory>>(); 1407 this.category.add(t); 1408 return t; 1409 } 1410 1411 /** 1412 * @param value {@link #category} (Category of the identified substance.) 1413 */ 1414 public AllergyIntolerance addCategory(AllergyIntoleranceCategory value) { //1 1415 Enumeration<AllergyIntoleranceCategory> t = new Enumeration<AllergyIntoleranceCategory>(new AllergyIntoleranceCategoryEnumFactory()); 1416 t.setValue(value); 1417 if (this.category == null) 1418 this.category = new ArrayList<Enumeration<AllergyIntoleranceCategory>>(); 1419 this.category.add(t); 1420 return this; 1421 } 1422 1423 /** 1424 * @param value {@link #category} (Category of the identified substance.) 1425 */ 1426 public boolean hasCategory(AllergyIntoleranceCategory value) { 1427 if (this.category == null) 1428 return false; 1429 for (Enumeration<AllergyIntoleranceCategory> v : this.category) 1430 if (v.getValue().equals(value)) // code 1431 return true; 1432 return false; 1433 } 1434 1435 /** 1436 * @return {@link #criticality} (Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance.). This is the underlying object with id, value and extensions. The accessor "getCriticality" gives direct access to the value 1437 */ 1438 public Enumeration<AllergyIntoleranceCriticality> getCriticalityElement() { 1439 if (this.criticality == null) 1440 if (Configuration.errorOnAutoCreate()) 1441 throw new Error("Attempt to auto-create AllergyIntolerance.criticality"); 1442 else if (Configuration.doAutoCreate()) 1443 this.criticality = new Enumeration<AllergyIntoleranceCriticality>(new AllergyIntoleranceCriticalityEnumFactory()); // bb 1444 return this.criticality; 1445 } 1446 1447 public boolean hasCriticalityElement() { 1448 return this.criticality != null && !this.criticality.isEmpty(); 1449 } 1450 1451 public boolean hasCriticality() { 1452 return this.criticality != null && !this.criticality.isEmpty(); 1453 } 1454 1455 /** 1456 * @param value {@link #criticality} (Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance.). This is the underlying object with id, value and extensions. The accessor "getCriticality" gives direct access to the value 1457 */ 1458 public AllergyIntolerance setCriticalityElement(Enumeration<AllergyIntoleranceCriticality> value) { 1459 this.criticality = value; 1460 return this; 1461 } 1462 1463 /** 1464 * @return Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance. 1465 */ 1466 public AllergyIntoleranceCriticality getCriticality() { 1467 return this.criticality == null ? null : this.criticality.getValue(); 1468 } 1469 1470 /** 1471 * @param value Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance. 1472 */ 1473 public AllergyIntolerance setCriticality(AllergyIntoleranceCriticality value) { 1474 if (value == null) 1475 this.criticality = null; 1476 else { 1477 if (this.criticality == null) 1478 this.criticality = new Enumeration<AllergyIntoleranceCriticality>(new AllergyIntoleranceCriticalityEnumFactory()); 1479 this.criticality.setValue(value); 1480 } 1481 return this; 1482 } 1483 1484 /** 1485 * @return {@link #code} (Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., "Latex"), an allergy or intolerance condition (e.g., "Latex allergy"), or a negated/excluded code for a specific substance or class (e.g., "No latex allergy") or a general or categorical negated statement (e.g., "No known allergy", "No known drug allergies"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.) 1486 */ 1487 public CodeableConcept getCode() { 1488 if (this.code == null) 1489 if (Configuration.errorOnAutoCreate()) 1490 throw new Error("Attempt to auto-create AllergyIntolerance.code"); 1491 else if (Configuration.doAutoCreate()) 1492 this.code = new CodeableConcept(); // cc 1493 return this.code; 1494 } 1495 1496 public boolean hasCode() { 1497 return this.code != null && !this.code.isEmpty(); 1498 } 1499 1500 /** 1501 * @param value {@link #code} (Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., "Latex"), an allergy or intolerance condition (e.g., "Latex allergy"), or a negated/excluded code for a specific substance or class (e.g., "No latex allergy") or a general or categorical negated statement (e.g., "No known allergy", "No known drug allergies"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.) 1502 */ 1503 public AllergyIntolerance setCode(CodeableConcept value) { 1504 this.code = value; 1505 return this; 1506 } 1507 1508 /** 1509 * @return {@link #patient} (The patient who has the allergy or intolerance.) 1510 */ 1511 public Reference getPatient() { 1512 if (this.patient == null) 1513 if (Configuration.errorOnAutoCreate()) 1514 throw new Error("Attempt to auto-create AllergyIntolerance.patient"); 1515 else if (Configuration.doAutoCreate()) 1516 this.patient = new Reference(); // cc 1517 return this.patient; 1518 } 1519 1520 public boolean hasPatient() { 1521 return this.patient != null && !this.patient.isEmpty(); 1522 } 1523 1524 /** 1525 * @param value {@link #patient} (The patient who has the allergy or intolerance.) 1526 */ 1527 public AllergyIntolerance setPatient(Reference value) { 1528 this.patient = value; 1529 return this; 1530 } 1531 1532 /** 1533 * @return {@link #encounter} (The encounter when the allergy or intolerance was asserted.) 1534 */ 1535 public Reference getEncounter() { 1536 if (this.encounter == null) 1537 if (Configuration.errorOnAutoCreate()) 1538 throw new Error("Attempt to auto-create AllergyIntolerance.encounter"); 1539 else if (Configuration.doAutoCreate()) 1540 this.encounter = new Reference(); // cc 1541 return this.encounter; 1542 } 1543 1544 public boolean hasEncounter() { 1545 return this.encounter != null && !this.encounter.isEmpty(); 1546 } 1547 1548 /** 1549 * @param value {@link #encounter} (The encounter when the allergy or intolerance was asserted.) 1550 */ 1551 public AllergyIntolerance setEncounter(Reference value) { 1552 this.encounter = value; 1553 return this; 1554 } 1555 1556 /** 1557 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1558 */ 1559 public DataType getOnset() { 1560 return this.onset; 1561 } 1562 1563 /** 1564 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1565 */ 1566 public DateTimeType getOnsetDateTimeType() throws FHIRException { 1567 if (this.onset == null) 1568 this.onset = new DateTimeType(); 1569 if (!(this.onset instanceof DateTimeType)) 1570 throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.onset.getClass().getName()+" was encountered"); 1571 return (DateTimeType) this.onset; 1572 } 1573 1574 public boolean hasOnsetDateTimeType() { 1575 return this != null && this.onset instanceof DateTimeType; 1576 } 1577 1578 /** 1579 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1580 */ 1581 public Age getOnsetAge() throws FHIRException { 1582 if (this.onset == null) 1583 this.onset = new Age(); 1584 if (!(this.onset instanceof Age)) 1585 throw new FHIRException("Type mismatch: the type Age was expected, but "+this.onset.getClass().getName()+" was encountered"); 1586 return (Age) this.onset; 1587 } 1588 1589 public boolean hasOnsetAge() { 1590 return this != null && this.onset instanceof Age; 1591 } 1592 1593 /** 1594 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1595 */ 1596 public Period getOnsetPeriod() throws FHIRException { 1597 if (this.onset == null) 1598 this.onset = new Period(); 1599 if (!(this.onset instanceof Period)) 1600 throw new FHIRException("Type mismatch: the type Period was expected, but "+this.onset.getClass().getName()+" was encountered"); 1601 return (Period) this.onset; 1602 } 1603 1604 public boolean hasOnsetPeriod() { 1605 return this != null && this.onset instanceof Period; 1606 } 1607 1608 /** 1609 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1610 */ 1611 public Range getOnsetRange() throws FHIRException { 1612 if (this.onset == null) 1613 this.onset = new Range(); 1614 if (!(this.onset instanceof Range)) 1615 throw new FHIRException("Type mismatch: the type Range was expected, but "+this.onset.getClass().getName()+" was encountered"); 1616 return (Range) this.onset; 1617 } 1618 1619 public boolean hasOnsetRange() { 1620 return this != null && this.onset instanceof Range; 1621 } 1622 1623 /** 1624 * @return {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1625 */ 1626 public StringType getOnsetStringType() throws FHIRException { 1627 if (this.onset == null) 1628 this.onset = new StringType(); 1629 if (!(this.onset instanceof StringType)) 1630 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.onset.getClass().getName()+" was encountered"); 1631 return (StringType) this.onset; 1632 } 1633 1634 public boolean hasOnsetStringType() { 1635 return this != null && this.onset instanceof StringType; 1636 } 1637 1638 public boolean hasOnset() { 1639 return this.onset != null && !this.onset.isEmpty(); 1640 } 1641 1642 /** 1643 * @param value {@link #onset} (Estimated or actual date, date-time, or age when allergy or intolerance was identified.) 1644 */ 1645 public AllergyIntolerance setOnset(DataType value) { 1646 if (value != null && !(value instanceof DateTimeType || value instanceof Age || value instanceof Period || value instanceof Range || value instanceof StringType)) 1647 throw new Error("Not the right type for AllergyIntolerance.onset[x]: "+value.fhirType()); 1648 this.onset = value; 1649 return this; 1650 } 1651 1652 /** 1653 * @return {@link #recordedDate} (The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date.). This is the underlying object with id, value and extensions. The accessor "getRecordedDate" gives direct access to the value 1654 */ 1655 public DateTimeType getRecordedDateElement() { 1656 if (this.recordedDate == null) 1657 if (Configuration.errorOnAutoCreate()) 1658 throw new Error("Attempt to auto-create AllergyIntolerance.recordedDate"); 1659 else if (Configuration.doAutoCreate()) 1660 this.recordedDate = new DateTimeType(); // bb 1661 return this.recordedDate; 1662 } 1663 1664 public boolean hasRecordedDateElement() { 1665 return this.recordedDate != null && !this.recordedDate.isEmpty(); 1666 } 1667 1668 public boolean hasRecordedDate() { 1669 return this.recordedDate != null && !this.recordedDate.isEmpty(); 1670 } 1671 1672 /** 1673 * @param value {@link #recordedDate} (The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date.). This is the underlying object with id, value and extensions. The accessor "getRecordedDate" gives direct access to the value 1674 */ 1675 public AllergyIntolerance setRecordedDateElement(DateTimeType value) { 1676 this.recordedDate = value; 1677 return this; 1678 } 1679 1680 /** 1681 * @return The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date. 1682 */ 1683 public Date getRecordedDate() { 1684 return this.recordedDate == null ? null : this.recordedDate.getValue(); 1685 } 1686 1687 /** 1688 * @param value The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date. 1689 */ 1690 public AllergyIntolerance setRecordedDate(Date value) { 1691 if (value == null) 1692 this.recordedDate = null; 1693 else { 1694 if (this.recordedDate == null) 1695 this.recordedDate = new DateTimeType(); 1696 this.recordedDate.setValue(value); 1697 } 1698 return this; 1699 } 1700 1701 /** 1702 * @return {@link #recorder} (Individual who recorded the record and takes responsibility for its content.) 1703 */ 1704 public Reference getRecorder() { 1705 if (this.recorder == null) 1706 if (Configuration.errorOnAutoCreate()) 1707 throw new Error("Attempt to auto-create AllergyIntolerance.recorder"); 1708 else if (Configuration.doAutoCreate()) 1709 this.recorder = new Reference(); // cc 1710 return this.recorder; 1711 } 1712 1713 public boolean hasRecorder() { 1714 return this.recorder != null && !this.recorder.isEmpty(); 1715 } 1716 1717 /** 1718 * @param value {@link #recorder} (Individual who recorded the record and takes responsibility for its content.) 1719 */ 1720 public AllergyIntolerance setRecorder(Reference value) { 1721 this.recorder = value; 1722 return this; 1723 } 1724 1725 /** 1726 * @return {@link #asserter} (The source of the information about the allergy that is recorded.) 1727 */ 1728 public Reference getAsserter() { 1729 if (this.asserter == null) 1730 if (Configuration.errorOnAutoCreate()) 1731 throw new Error("Attempt to auto-create AllergyIntolerance.asserter"); 1732 else if (Configuration.doAutoCreate()) 1733 this.asserter = new Reference(); // cc 1734 return this.asserter; 1735 } 1736 1737 public boolean hasAsserter() { 1738 return this.asserter != null && !this.asserter.isEmpty(); 1739 } 1740 1741 /** 1742 * @param value {@link #asserter} (The source of the information about the allergy that is recorded.) 1743 */ 1744 public AllergyIntolerance setAsserter(Reference value) { 1745 this.asserter = value; 1746 return this; 1747 } 1748 1749 /** 1750 * @return {@link #lastOccurrence} (Represents the date and/or time of the last known occurrence of a reaction event.). This is the underlying object with id, value and extensions. The accessor "getLastOccurrence" gives direct access to the value 1751 */ 1752 public DateTimeType getLastOccurrenceElement() { 1753 if (this.lastOccurrence == null) 1754 if (Configuration.errorOnAutoCreate()) 1755 throw new Error("Attempt to auto-create AllergyIntolerance.lastOccurrence"); 1756 else if (Configuration.doAutoCreate()) 1757 this.lastOccurrence = new DateTimeType(); // bb 1758 return this.lastOccurrence; 1759 } 1760 1761 public boolean hasLastOccurrenceElement() { 1762 return this.lastOccurrence != null && !this.lastOccurrence.isEmpty(); 1763 } 1764 1765 public boolean hasLastOccurrence() { 1766 return this.lastOccurrence != null && !this.lastOccurrence.isEmpty(); 1767 } 1768 1769 /** 1770 * @param value {@link #lastOccurrence} (Represents the date and/or time of the last known occurrence of a reaction event.). This is the underlying object with id, value and extensions. The accessor "getLastOccurrence" gives direct access to the value 1771 */ 1772 public AllergyIntolerance setLastOccurrenceElement(DateTimeType value) { 1773 this.lastOccurrence = value; 1774 return this; 1775 } 1776 1777 /** 1778 * @return Represents the date and/or time of the last known occurrence of a reaction event. 1779 */ 1780 public Date getLastOccurrence() { 1781 return this.lastOccurrence == null ? null : this.lastOccurrence.getValue(); 1782 } 1783 1784 /** 1785 * @param value Represents the date and/or time of the last known occurrence of a reaction event. 1786 */ 1787 public AllergyIntolerance setLastOccurrence(Date value) { 1788 if (value == null) 1789 this.lastOccurrence = null; 1790 else { 1791 if (this.lastOccurrence == null) 1792 this.lastOccurrence = new DateTimeType(); 1793 this.lastOccurrence.setValue(value); 1794 } 1795 return this; 1796 } 1797 1798 /** 1799 * @return {@link #note} (Additional narrative about the propensity for the Adverse Reaction, not captured in other fields.) 1800 */ 1801 public List<Annotation> getNote() { 1802 if (this.note == null) 1803 this.note = new ArrayList<Annotation>(); 1804 return this.note; 1805 } 1806 1807 /** 1808 * @return Returns a reference to <code>this</code> for easy method chaining 1809 */ 1810 public AllergyIntolerance setNote(List<Annotation> theNote) { 1811 this.note = theNote; 1812 return this; 1813 } 1814 1815 public boolean hasNote() { 1816 if (this.note == null) 1817 return false; 1818 for (Annotation item : this.note) 1819 if (!item.isEmpty()) 1820 return true; 1821 return false; 1822 } 1823 1824 public Annotation addNote() { //3 1825 Annotation t = new Annotation(); 1826 if (this.note == null) 1827 this.note = new ArrayList<Annotation>(); 1828 this.note.add(t); 1829 return t; 1830 } 1831 1832 public AllergyIntolerance addNote(Annotation t) { //3 1833 if (t == null) 1834 return this; 1835 if (this.note == null) 1836 this.note = new ArrayList<Annotation>(); 1837 this.note.add(t); 1838 return this; 1839 } 1840 1841 /** 1842 * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist {3} 1843 */ 1844 public Annotation getNoteFirstRep() { 1845 if (getNote().isEmpty()) { 1846 addNote(); 1847 } 1848 return getNote().get(0); 1849 } 1850 1851 /** 1852 * @return {@link #reaction} (Details about each adverse reaction event linked to exposure to the identified substance.) 1853 */ 1854 public List<AllergyIntoleranceReactionComponent> getReaction() { 1855 if (this.reaction == null) 1856 this.reaction = new ArrayList<AllergyIntoleranceReactionComponent>(); 1857 return this.reaction; 1858 } 1859 1860 /** 1861 * @return Returns a reference to <code>this</code> for easy method chaining 1862 */ 1863 public AllergyIntolerance setReaction(List<AllergyIntoleranceReactionComponent> theReaction) { 1864 this.reaction = theReaction; 1865 return this; 1866 } 1867 1868 public boolean hasReaction() { 1869 if (this.reaction == null) 1870 return false; 1871 for (AllergyIntoleranceReactionComponent item : this.reaction) 1872 if (!item.isEmpty()) 1873 return true; 1874 return false; 1875 } 1876 1877 public AllergyIntoleranceReactionComponent addReaction() { //3 1878 AllergyIntoleranceReactionComponent t = new AllergyIntoleranceReactionComponent(); 1879 if (this.reaction == null) 1880 this.reaction = new ArrayList<AllergyIntoleranceReactionComponent>(); 1881 this.reaction.add(t); 1882 return t; 1883 } 1884 1885 public AllergyIntolerance addReaction(AllergyIntoleranceReactionComponent t) { //3 1886 if (t == null) 1887 return this; 1888 if (this.reaction == null) 1889 this.reaction = new ArrayList<AllergyIntoleranceReactionComponent>(); 1890 this.reaction.add(t); 1891 return this; 1892 } 1893 1894 /** 1895 * @return The first repetition of repeating field {@link #reaction}, creating it if it does not already exist {3} 1896 */ 1897 public AllergyIntoleranceReactionComponent getReactionFirstRep() { 1898 if (getReaction().isEmpty()) { 1899 addReaction(); 1900 } 1901 return getReaction().get(0); 1902 } 1903 1904 protected void listChildren(List<Property> children) { 1905 super.listChildren(children); 1906 children.add(new Property("identifier", "Identifier", "Business identifiers assigned to this AllergyIntolerance by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier)); 1907 children.add(new Property("clinicalStatus", "CodeableConcept", "The clinical status of the allergy or intolerance.", 0, 1, clinicalStatus)); 1908 children.add(new Property("verificationStatus", "CodeableConcept", "Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product).", 0, 1, verificationStatus)); 1909 children.add(new Property("type", "code", "Identification of the underlying physiological mechanism for the reaction risk.", 0, 1, type)); 1910 children.add(new Property("category", "code", "Category of the identified substance.", 0, java.lang.Integer.MAX_VALUE, category)); 1911 children.add(new Property("criticality", "code", "Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance.", 0, 1, criticality)); 1912 children.add(new Property("code", "CodeableConcept", "Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., \"Latex\"), an allergy or intolerance condition (e.g., \"Latex allergy\"), or a negated/excluded code for a specific substance or class (e.g., \"No latex allergy\") or a general or categorical negated statement (e.g., \"No known allergy\", \"No known drug allergies\"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.", 0, 1, code)); 1913 children.add(new Property("patient", "Reference(Patient)", "The patient who has the allergy or intolerance.", 0, 1, patient)); 1914 children.add(new Property("encounter", "Reference(Encounter)", "The encounter when the allergy or intolerance was asserted.", 0, 1, encounter)); 1915 children.add(new Property("onset[x]", "dateTime|Age|Period|Range|string", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset)); 1916 children.add(new Property("recordedDate", "dateTime", "The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date.", 0, 1, recordedDate)); 1917 children.add(new Property("recorder", "Reference(Practitioner|PractitionerRole|Patient|RelatedPerson)", "Individual who recorded the record and takes responsibility for its content.", 0, 1, recorder)); 1918 children.add(new Property("asserter", "Reference(Patient|RelatedPerson|Practitioner|PractitionerRole)", "The source of the information about the allergy that is recorded.", 0, 1, asserter)); 1919 children.add(new Property("lastOccurrence", "dateTime", "Represents the date and/or time of the last known occurrence of a reaction event.", 0, 1, lastOccurrence)); 1920 children.add(new Property("note", "Annotation", "Additional narrative about the propensity for the Adverse Reaction, not captured in other fields.", 0, java.lang.Integer.MAX_VALUE, note)); 1921 children.add(new Property("reaction", "", "Details about each adverse reaction event linked to exposure to the identified substance.", 0, java.lang.Integer.MAX_VALUE, reaction)); 1922 } 1923 1924 @Override 1925 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1926 switch (_hash) { 1927 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "Business identifiers assigned to this AllergyIntolerance by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier); 1928 case -462853915: /*clinicalStatus*/ return new Property("clinicalStatus", "CodeableConcept", "The clinical status of the allergy or intolerance.", 0, 1, clinicalStatus); 1929 case -842509843: /*verificationStatus*/ return new Property("verificationStatus", "CodeableConcept", "Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product).", 0, 1, verificationStatus); 1930 case 3575610: /*type*/ return new Property("type", "code", "Identification of the underlying physiological mechanism for the reaction risk.", 0, 1, type); 1931 case 50511102: /*category*/ return new Property("category", "code", "Category of the identified substance.", 0, java.lang.Integer.MAX_VALUE, category); 1932 case -1608054609: /*criticality*/ return new Property("criticality", "code", "Estimate of the potential clinical harm, or seriousness, of the reaction to the identified substance.", 0, 1, criticality); 1933 case 3059181: /*code*/ return new Property("code", "CodeableConcept", "Code for an allergy or intolerance statement (either a positive or a negated/excluded statement). This may be a code for a substance or pharmaceutical product that is considered to be responsible for the adverse reaction risk (e.g., \"Latex\"), an allergy or intolerance condition (e.g., \"Latex allergy\"), or a negated/excluded code for a specific substance or class (e.g., \"No latex allergy\") or a general or categorical negated statement (e.g., \"No known allergy\", \"No known drug allergies\"). Note: the substance for a specific reaction may be different from the substance identified as the cause of the risk, but it must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite product that includes the identified substance. It must be clinically safe to only process the 'code' and ignore the 'reaction.substance'. If a receiving system is unable to confirm that AllergyIntolerance.reaction.substance falls within the semantic scope of AllergyIntolerance.code, then the receiving system should ignore AllergyIntolerance.reaction.substance.", 0, 1, code); 1934 case -791418107: /*patient*/ return new Property("patient", "Reference(Patient)", "The patient who has the allergy or intolerance.", 0, 1, patient); 1935 case 1524132147: /*encounter*/ return new Property("encounter", "Reference(Encounter)", "The encounter when the allergy or intolerance was asserted.", 0, 1, encounter); 1936 case -1886216323: /*onset[x]*/ return new Property("onset[x]", "dateTime|Age|Period|Range|string", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1937 case 105901603: /*onset*/ return new Property("onset[x]", "dateTime|Age|Period|Range|string", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1938 case -1701663010: /*onsetDateTime*/ return new Property("onset[x]", "dateTime", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1939 case -1886241828: /*onsetAge*/ return new Property("onset[x]", "Age", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1940 case -1545082428: /*onsetPeriod*/ return new Property("onset[x]", "Period", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1941 case -186664742: /*onsetRange*/ return new Property("onset[x]", "Range", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1942 case -1445342188: /*onsetString*/ return new Property("onset[x]", "string", "Estimated or actual date, date-time, or age when allergy or intolerance was identified.", 0, 1, onset); 1943 case -1952893826: /*recordedDate*/ return new Property("recordedDate", "dateTime", "The recordedDate represents when this particular AllergyIntolerance record was created in the system, which is often a system-generated date.", 0, 1, recordedDate); 1944 case -799233858: /*recorder*/ return new Property("recorder", "Reference(Practitioner|PractitionerRole|Patient|RelatedPerson)", "Individual who recorded the record and takes responsibility for its content.", 0, 1, recorder); 1945 case -373242253: /*asserter*/ return new Property("asserter", "Reference(Patient|RelatedPerson|Practitioner|PractitionerRole)", "The source of the information about the allergy that is recorded.", 0, 1, asserter); 1946 case 1896977671: /*lastOccurrence*/ return new Property("lastOccurrence", "dateTime", "Represents the date and/or time of the last known occurrence of a reaction event.", 0, 1, lastOccurrence); 1947 case 3387378: /*note*/ return new Property("note", "Annotation", "Additional narrative about the propensity for the Adverse Reaction, not captured in other fields.", 0, java.lang.Integer.MAX_VALUE, note); 1948 case -867509719: /*reaction*/ return new Property("reaction", "", "Details about each adverse reaction event linked to exposure to the identified substance.", 0, java.lang.Integer.MAX_VALUE, reaction); 1949 default: return super.getNamedProperty(_hash, _name, _checkValid); 1950 } 1951 1952 } 1953 1954 @Override 1955 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1956 switch (hash) { 1957 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 1958 case -462853915: /*clinicalStatus*/ return this.clinicalStatus == null ? new Base[0] : new Base[] {this.clinicalStatus}; // CodeableConcept 1959 case -842509843: /*verificationStatus*/ return this.verificationStatus == null ? new Base[0] : new Base[] {this.verificationStatus}; // CodeableConcept 1960 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<AllergyIntoleranceType> 1961 case 50511102: /*category*/ return this.category == null ? new Base[0] : this.category.toArray(new Base[this.category.size()]); // Enumeration<AllergyIntoleranceCategory> 1962 case -1608054609: /*criticality*/ return this.criticality == null ? new Base[0] : new Base[] {this.criticality}; // Enumeration<AllergyIntoleranceCriticality> 1963 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept 1964 case -791418107: /*patient*/ return this.patient == null ? new Base[0] : new Base[] {this.patient}; // Reference 1965 case 1524132147: /*encounter*/ return this.encounter == null ? new Base[0] : new Base[] {this.encounter}; // Reference 1966 case 105901603: /*onset*/ return this.onset == null ? new Base[0] : new Base[] {this.onset}; // DataType 1967 case -1952893826: /*recordedDate*/ return this.recordedDate == null ? new Base[0] : new Base[] {this.recordedDate}; // DateTimeType 1968 case -799233858: /*recorder*/ return this.recorder == null ? new Base[0] : new Base[] {this.recorder}; // Reference 1969 case -373242253: /*asserter*/ return this.asserter == null ? new Base[0] : new Base[] {this.asserter}; // Reference 1970 case 1896977671: /*lastOccurrence*/ return this.lastOccurrence == null ? new Base[0] : new Base[] {this.lastOccurrence}; // DateTimeType 1971 case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 1972 case -867509719: /*reaction*/ return this.reaction == null ? new Base[0] : this.reaction.toArray(new Base[this.reaction.size()]); // AllergyIntoleranceReactionComponent 1973 default: return super.getProperty(hash, name, checkValid); 1974 } 1975 1976 } 1977 1978 @Override 1979 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1980 switch (hash) { 1981 case -1618432855: // identifier 1982 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier 1983 return value; 1984 case -462853915: // clinicalStatus 1985 this.clinicalStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1986 return value; 1987 case -842509843: // verificationStatus 1988 this.verificationStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 1989 return value; 1990 case 3575610: // type 1991 value = new AllergyIntoleranceTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 1992 this.type = (Enumeration) value; // Enumeration<AllergyIntoleranceType> 1993 return value; 1994 case 50511102: // category 1995 value = new AllergyIntoleranceCategoryEnumFactory().fromType(TypeConvertor.castToCode(value)); 1996 this.getCategory().add((Enumeration) value); // Enumeration<AllergyIntoleranceCategory> 1997 return value; 1998 case -1608054609: // criticality 1999 value = new AllergyIntoleranceCriticalityEnumFactory().fromType(TypeConvertor.castToCode(value)); 2000 this.criticality = (Enumeration) value; // Enumeration<AllergyIntoleranceCriticality> 2001 return value; 2002 case 3059181: // code 2003 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 2004 return value; 2005 case -791418107: // patient 2006 this.patient = TypeConvertor.castToReference(value); // Reference 2007 return value; 2008 case 1524132147: // encounter 2009 this.encounter = TypeConvertor.castToReference(value); // Reference 2010 return value; 2011 case 105901603: // onset 2012 this.onset = TypeConvertor.castToType(value); // DataType 2013 return value; 2014 case -1952893826: // recordedDate 2015 this.recordedDate = TypeConvertor.castToDateTime(value); // DateTimeType 2016 return value; 2017 case -799233858: // recorder 2018 this.recorder = TypeConvertor.castToReference(value); // Reference 2019 return value; 2020 case -373242253: // asserter 2021 this.asserter = TypeConvertor.castToReference(value); // Reference 2022 return value; 2023 case 1896977671: // lastOccurrence 2024 this.lastOccurrence = TypeConvertor.castToDateTime(value); // DateTimeType 2025 return value; 2026 case 3387378: // note 2027 this.getNote().add(TypeConvertor.castToAnnotation(value)); // Annotation 2028 return value; 2029 case -867509719: // reaction 2030 this.getReaction().add((AllergyIntoleranceReactionComponent) value); // AllergyIntoleranceReactionComponent 2031 return value; 2032 default: return super.setProperty(hash, name, value); 2033 } 2034 2035 } 2036 2037 @Override 2038 public Base setProperty(String name, Base value) throws FHIRException { 2039 if (name.equals("identifier")) { 2040 this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); 2041 } else if (name.equals("clinicalStatus")) { 2042 this.clinicalStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 2043 } else if (name.equals("verificationStatus")) { 2044 this.verificationStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 2045 } else if (name.equals("type")) { 2046 value = new AllergyIntoleranceTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2047 this.type = (Enumeration) value; // Enumeration<AllergyIntoleranceType> 2048 } else if (name.equals("category")) { 2049 value = new AllergyIntoleranceCategoryEnumFactory().fromType(TypeConvertor.castToCode(value)); 2050 this.getCategory().add((Enumeration) value); 2051 } else if (name.equals("criticality")) { 2052 value = new AllergyIntoleranceCriticalityEnumFactory().fromType(TypeConvertor.castToCode(value)); 2053 this.criticality = (Enumeration) value; // Enumeration<AllergyIntoleranceCriticality> 2054 } else if (name.equals("code")) { 2055 this.code = TypeConvertor.castToCodeableConcept(value); // CodeableConcept 2056 } else if (name.equals("patient")) { 2057 this.patient = TypeConvertor.castToReference(value); // Reference 2058 } else if (name.equals("encounter")) { 2059 this.encounter = TypeConvertor.castToReference(value); // Reference 2060 } else if (name.equals("onset[x]")) { 2061 this.onset = TypeConvertor.castToType(value); // DataType 2062 } else if (name.equals("recordedDate")) { 2063 this.recordedDate = TypeConvertor.castToDateTime(value); // DateTimeType 2064 } else if (name.equals("recorder")) { 2065 this.recorder = TypeConvertor.castToReference(value); // Reference 2066 } else if (name.equals("asserter")) { 2067 this.asserter = TypeConvertor.castToReference(value); // Reference 2068 } else if (name.equals("lastOccurrence")) { 2069 this.lastOccurrence = TypeConvertor.castToDateTime(value); // DateTimeType 2070 } else if (name.equals("note")) { 2071 this.getNote().add(TypeConvertor.castToAnnotation(value)); 2072 } else if (name.equals("reaction")) { 2073 this.getReaction().add((AllergyIntoleranceReactionComponent) value); 2074 } else 2075 return super.setProperty(name, value); 2076 return value; 2077 } 2078 2079 @Override 2080 public Base makeProperty(int hash, String name) throws FHIRException { 2081 switch (hash) { 2082 case -1618432855: return addIdentifier(); 2083 case -462853915: return getClinicalStatus(); 2084 case -842509843: return getVerificationStatus(); 2085 case 3575610: return getTypeElement(); 2086 case 50511102: return addCategoryElement(); 2087 case -1608054609: return getCriticalityElement(); 2088 case 3059181: return getCode(); 2089 case -791418107: return getPatient(); 2090 case 1524132147: return getEncounter(); 2091 case -1886216323: return getOnset(); 2092 case 105901603: return getOnset(); 2093 case -1952893826: return getRecordedDateElement(); 2094 case -799233858: return getRecorder(); 2095 case -373242253: return getAsserter(); 2096 case 1896977671: return getLastOccurrenceElement(); 2097 case 3387378: return addNote(); 2098 case -867509719: return addReaction(); 2099 default: return super.makeProperty(hash, name); 2100 } 2101 2102 } 2103 2104 @Override 2105 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2106 switch (hash) { 2107 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 2108 case -462853915: /*clinicalStatus*/ return new String[] {"CodeableConcept"}; 2109 case -842509843: /*verificationStatus*/ return new String[] {"CodeableConcept"}; 2110 case 3575610: /*type*/ return new String[] {"code"}; 2111 case 50511102: /*category*/ return new String[] {"code"}; 2112 case -1608054609: /*criticality*/ return new String[] {"code"}; 2113 case 3059181: /*code*/ return new String[] {"CodeableConcept"}; 2114 case -791418107: /*patient*/ return new String[] {"Reference"}; 2115 case 1524132147: /*encounter*/ return new String[] {"Reference"}; 2116 case 105901603: /*onset*/ return new String[] {"dateTime", "Age", "Period", "Range", "string"}; 2117 case -1952893826: /*recordedDate*/ return new String[] {"dateTime"}; 2118 case -799233858: /*recorder*/ return new String[] {"Reference"}; 2119 case -373242253: /*asserter*/ return new String[] {"Reference"}; 2120 case 1896977671: /*lastOccurrence*/ return new String[] {"dateTime"}; 2121 case 3387378: /*note*/ return new String[] {"Annotation"}; 2122 case -867509719: /*reaction*/ return new String[] {}; 2123 default: return super.getTypesForProperty(hash, name); 2124 } 2125 2126 } 2127 2128 @Override 2129 public Base addChild(String name) throws FHIRException { 2130 if (name.equals("identifier")) { 2131 return addIdentifier(); 2132 } 2133 else if (name.equals("clinicalStatus")) { 2134 this.clinicalStatus = new CodeableConcept(); 2135 return this.clinicalStatus; 2136 } 2137 else if (name.equals("verificationStatus")) { 2138 this.verificationStatus = new CodeableConcept(); 2139 return this.verificationStatus; 2140 } 2141 else if (name.equals("type")) { 2142 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.type"); 2143 } 2144 else if (name.equals("category")) { 2145 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.category"); 2146 } 2147 else if (name.equals("criticality")) { 2148 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.criticality"); 2149 } 2150 else if (name.equals("code")) { 2151 this.code = new CodeableConcept(); 2152 return this.code; 2153 } 2154 else if (name.equals("patient")) { 2155 this.patient = new Reference(); 2156 return this.patient; 2157 } 2158 else if (name.equals("encounter")) { 2159 this.encounter = new Reference(); 2160 return this.encounter; 2161 } 2162 else if (name.equals("onsetDateTime")) { 2163 this.onset = new DateTimeType(); 2164 return this.onset; 2165 } 2166 else if (name.equals("onsetAge")) { 2167 this.onset = new Age(); 2168 return this.onset; 2169 } 2170 else if (name.equals("onsetPeriod")) { 2171 this.onset = new Period(); 2172 return this.onset; 2173 } 2174 else if (name.equals("onsetRange")) { 2175 this.onset = new Range(); 2176 return this.onset; 2177 } 2178 else if (name.equals("onsetString")) { 2179 this.onset = new StringType(); 2180 return this.onset; 2181 } 2182 else if (name.equals("recordedDate")) { 2183 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.recordedDate"); 2184 } 2185 else if (name.equals("recorder")) { 2186 this.recorder = new Reference(); 2187 return this.recorder; 2188 } 2189 else if (name.equals("asserter")) { 2190 this.asserter = new Reference(); 2191 return this.asserter; 2192 } 2193 else if (name.equals("lastOccurrence")) { 2194 throw new FHIRException("Cannot call addChild on a primitive type AllergyIntolerance.lastOccurrence"); 2195 } 2196 else if (name.equals("note")) { 2197 return addNote(); 2198 } 2199 else if (name.equals("reaction")) { 2200 return addReaction(); 2201 } 2202 else 2203 return super.addChild(name); 2204 } 2205 2206 public String fhirType() { 2207 return "AllergyIntolerance"; 2208 2209 } 2210 2211 public AllergyIntolerance copy() { 2212 AllergyIntolerance dst = new AllergyIntolerance(); 2213 copyValues(dst); 2214 return dst; 2215 } 2216 2217 public void copyValues(AllergyIntolerance dst) { 2218 super.copyValues(dst); 2219 if (identifier != null) { 2220 dst.identifier = new ArrayList<Identifier>(); 2221 for (Identifier i : identifier) 2222 dst.identifier.add(i.copy()); 2223 }; 2224 dst.clinicalStatus = clinicalStatus == null ? null : clinicalStatus.copy(); 2225 dst.verificationStatus = verificationStatus == null ? null : verificationStatus.copy(); 2226 dst.type = type == null ? null : type.copy(); 2227 if (category != null) { 2228 dst.category = new ArrayList<Enumeration<AllergyIntoleranceCategory>>(); 2229 for (Enumeration<AllergyIntoleranceCategory> i : category) 2230 dst.category.add(i.copy()); 2231 }; 2232 dst.criticality = criticality == null ? null : criticality.copy(); 2233 dst.code = code == null ? null : code.copy(); 2234 dst.patient = patient == null ? null : patient.copy(); 2235 dst.encounter = encounter == null ? null : encounter.copy(); 2236 dst.onset = onset == null ? null : onset.copy(); 2237 dst.recordedDate = recordedDate == null ? null : recordedDate.copy(); 2238 dst.recorder = recorder == null ? null : recorder.copy(); 2239 dst.asserter = asserter == null ? null : asserter.copy(); 2240 dst.lastOccurrence = lastOccurrence == null ? null : lastOccurrence.copy(); 2241 if (note != null) { 2242 dst.note = new ArrayList<Annotation>(); 2243 for (Annotation i : note) 2244 dst.note.add(i.copy()); 2245 }; 2246 if (reaction != null) { 2247 dst.reaction = new ArrayList<AllergyIntoleranceReactionComponent>(); 2248 for (AllergyIntoleranceReactionComponent i : reaction) 2249 dst.reaction.add(i.copy()); 2250 }; 2251 } 2252 2253 protected AllergyIntolerance typedCopy() { 2254 return copy(); 2255 } 2256 2257 @Override 2258 public boolean equalsDeep(Base other_) { 2259 if (!super.equalsDeep(other_)) 2260 return false; 2261 if (!(other_ instanceof AllergyIntolerance)) 2262 return false; 2263 AllergyIntolerance o = (AllergyIntolerance) other_; 2264 return compareDeep(identifier, o.identifier, true) && compareDeep(clinicalStatus, o.clinicalStatus, true) 2265 && compareDeep(verificationStatus, o.verificationStatus, true) && compareDeep(type, o.type, true) 2266 && compareDeep(category, o.category, true) && compareDeep(criticality, o.criticality, true) && compareDeep(code, o.code, true) 2267 && compareDeep(patient, o.patient, true) && compareDeep(encounter, o.encounter, true) && compareDeep(onset, o.onset, true) 2268 && compareDeep(recordedDate, o.recordedDate, true) && compareDeep(recorder, o.recorder, true) && compareDeep(asserter, o.asserter, true) 2269 && compareDeep(lastOccurrence, o.lastOccurrence, true) && compareDeep(note, o.note, true) && compareDeep(reaction, o.reaction, true) 2270 ; 2271 } 2272 2273 @Override 2274 public boolean equalsShallow(Base other_) { 2275 if (!super.equalsShallow(other_)) 2276 return false; 2277 if (!(other_ instanceof AllergyIntolerance)) 2278 return false; 2279 AllergyIntolerance o = (AllergyIntolerance) other_; 2280 return compareValues(type, o.type, true) && compareValues(category, o.category, true) && compareValues(criticality, o.criticality, true) 2281 && compareValues(recordedDate, o.recordedDate, true) && compareValues(lastOccurrence, o.lastOccurrence, true) 2282 ; 2283 } 2284 2285 public boolean isEmpty() { 2286 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, clinicalStatus 2287 , verificationStatus, type, category, criticality, code, patient, encounter, onset 2288 , recordedDate, recorder, asserter, lastOccurrence, note, reaction); 2289 } 2290 2291 @Override 2292 public ResourceType getResourceType() { 2293 return ResourceType.AllergyIntolerance; 2294 } 2295 2296 /** 2297 * Search parameter: <b>asserter</b> 2298 * <p> 2299 * Description: <b>Source of the information about the allergy</b><br> 2300 * Type: <b>reference</b><br> 2301 * Path: <b>AllergyIntolerance.asserter</b><br> 2302 * </p> 2303 */ 2304 @SearchParamDefinition(name="asserter", path="AllergyIntolerance.asserter", description="Source of the information about the allergy", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for RelatedPerson") }, target={Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class } ) 2305 public static final String SP_ASSERTER = "asserter"; 2306 /** 2307 * <b>Fluent Client</b> search parameter constant for <b>asserter</b> 2308 * <p> 2309 * Description: <b>Source of the information about the allergy</b><br> 2310 * Type: <b>reference</b><br> 2311 * Path: <b>AllergyIntolerance.asserter</b><br> 2312 * </p> 2313 */ 2314 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ASSERTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ASSERTER); 2315 2316/** 2317 * Constant for fluent queries to be used to add include statements. Specifies 2318 * the path value of "<b>AllergyIntolerance:asserter</b>". 2319 */ 2320 public static final ca.uhn.fhir.model.api.Include INCLUDE_ASSERTER = new ca.uhn.fhir.model.api.Include("AllergyIntolerance:asserter").toLocked(); 2321 2322 /** 2323 * Search parameter: <b>category</b> 2324 * <p> 2325 * Description: <b>food | medication | environment | biologic</b><br> 2326 * Type: <b>token</b><br> 2327 * Path: <b>AllergyIntolerance.category</b><br> 2328 * </p> 2329 */ 2330 @SearchParamDefinition(name="category", path="AllergyIntolerance.category", description="food | medication | environment | biologic", type="token" ) 2331 public static final String SP_CATEGORY = "category"; 2332 /** 2333 * <b>Fluent Client</b> search parameter constant for <b>category</b> 2334 * <p> 2335 * Description: <b>food | medication | environment | biologic</b><br> 2336 * Type: <b>token</b><br> 2337 * Path: <b>AllergyIntolerance.category</b><br> 2338 * </p> 2339 */ 2340 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CATEGORY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CATEGORY); 2341 2342 /** 2343 * Search parameter: <b>clinical-status</b> 2344 * <p> 2345 * Description: <b>active | inactive | resolved</b><br> 2346 * Type: <b>token</b><br> 2347 * Path: <b>AllergyIntolerance.clinicalStatus</b><br> 2348 * </p> 2349 */ 2350 @SearchParamDefinition(name="clinical-status", path="AllergyIntolerance.clinicalStatus", description="active | inactive | resolved", type="token" ) 2351 public static final String SP_CLINICAL_STATUS = "clinical-status"; 2352 /** 2353 * <b>Fluent Client</b> search parameter constant for <b>clinical-status</b> 2354 * <p> 2355 * Description: <b>active | inactive | resolved</b><br> 2356 * Type: <b>token</b><br> 2357 * Path: <b>AllergyIntolerance.clinicalStatus</b><br> 2358 * </p> 2359 */ 2360 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CLINICAL_STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CLINICAL_STATUS); 2361 2362 /** 2363 * Search parameter: <b>criticality</b> 2364 * <p> 2365 * Description: <b>low | high | unable-to-assess</b><br> 2366 * Type: <b>token</b><br> 2367 * Path: <b>AllergyIntolerance.criticality</b><br> 2368 * </p> 2369 */ 2370 @SearchParamDefinition(name="criticality", path="AllergyIntolerance.criticality", description="low | high | unable-to-assess", type="token" ) 2371 public static final String SP_CRITICALITY = "criticality"; 2372 /** 2373 * <b>Fluent Client</b> search parameter constant for <b>criticality</b> 2374 * <p> 2375 * Description: <b>low | high | unable-to-assess</b><br> 2376 * Type: <b>token</b><br> 2377 * Path: <b>AllergyIntolerance.criticality</b><br> 2378 * </p> 2379 */ 2380 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CRITICALITY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CRITICALITY); 2381 2382 /** 2383 * Search parameter: <b>last-date</b> 2384 * <p> 2385 * Description: <b>Date(/time) of last known occurrence of a reaction</b><br> 2386 * Type: <b>date</b><br> 2387 * Path: <b>AllergyIntolerance.lastOccurrence</b><br> 2388 * </p> 2389 */ 2390 @SearchParamDefinition(name="last-date", path="AllergyIntolerance.lastOccurrence", description="Date(/time) of last known occurrence of a reaction", type="date" ) 2391 public static final String SP_LAST_DATE = "last-date"; 2392 /** 2393 * <b>Fluent Client</b> search parameter constant for <b>last-date</b> 2394 * <p> 2395 * Description: <b>Date(/time) of last known occurrence of a reaction</b><br> 2396 * Type: <b>date</b><br> 2397 * Path: <b>AllergyIntolerance.lastOccurrence</b><br> 2398 * </p> 2399 */ 2400 public static final ca.uhn.fhir.rest.gclient.DateClientParam LAST_DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_LAST_DATE); 2401 2402 /** 2403 * Search parameter: <b>manifestation</b> 2404 * <p> 2405 * Description: <b>Clinical symptoms/signs associated with the Event</b><br> 2406 * Type: <b>token</b><br> 2407 * Path: <b>AllergyIntolerance.reaction.manifestation</b><br> 2408 * </p> 2409 */ 2410 @SearchParamDefinition(name="manifestation", path="AllergyIntolerance.reaction.manifestation", description="Clinical symptoms/signs associated with the Event", type="token" ) 2411 public static final String SP_MANIFESTATION = "manifestation"; 2412 /** 2413 * <b>Fluent Client</b> search parameter constant for <b>manifestation</b> 2414 * <p> 2415 * Description: <b>Clinical symptoms/signs associated with the Event</b><br> 2416 * Type: <b>token</b><br> 2417 * Path: <b>AllergyIntolerance.reaction.manifestation</b><br> 2418 * </p> 2419 */ 2420 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MANIFESTATION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MANIFESTATION); 2421 2422 /** 2423 * Search parameter: <b>onset</b> 2424 * <p> 2425 * Description: <b>Date(/time) when manifestations showed</b><br> 2426 * Type: <b>date</b><br> 2427 * Path: <b>AllergyIntolerance.reaction.onset</b><br> 2428 * </p> 2429 */ 2430 @SearchParamDefinition(name="onset", path="AllergyIntolerance.reaction.onset", description="Date(/time) when manifestations showed", type="date" ) 2431 public static final String SP_ONSET = "onset"; 2432 /** 2433 * <b>Fluent Client</b> search parameter constant for <b>onset</b> 2434 * <p> 2435 * Description: <b>Date(/time) when manifestations showed</b><br> 2436 * Type: <b>date</b><br> 2437 * Path: <b>AllergyIntolerance.reaction.onset</b><br> 2438 * </p> 2439 */ 2440 public static final ca.uhn.fhir.rest.gclient.DateClientParam ONSET = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_ONSET); 2441 2442 /** 2443 * Search parameter: <b>recorder</b> 2444 * <p> 2445 * Description: <b>Who recorded the sensitivity</b><br> 2446 * Type: <b>reference</b><br> 2447 * Path: <b>AllergyIntolerance.recorder</b><br> 2448 * </p> 2449 */ 2450 @SearchParamDefinition(name="recorder", path="AllergyIntolerance.recorder", description="Who recorded the sensitivity", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Practitioner") }, target={Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class } ) 2451 public static final String SP_RECORDER = "recorder"; 2452 /** 2453 * <b>Fluent Client</b> search parameter constant for <b>recorder</b> 2454 * <p> 2455 * Description: <b>Who recorded the sensitivity</b><br> 2456 * Type: <b>reference</b><br> 2457 * Path: <b>AllergyIntolerance.recorder</b><br> 2458 * </p> 2459 */ 2460 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RECORDER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RECORDER); 2461 2462/** 2463 * Constant for fluent queries to be used to add include statements. Specifies 2464 * the path value of "<b>AllergyIntolerance:recorder</b>". 2465 */ 2466 public static final ca.uhn.fhir.model.api.Include INCLUDE_RECORDER = new ca.uhn.fhir.model.api.Include("AllergyIntolerance:recorder").toLocked(); 2467 2468 /** 2469 * Search parameter: <b>route</b> 2470 * <p> 2471 * Description: <b>How the subject was exposed to the substance</b><br> 2472 * Type: <b>token</b><br> 2473 * Path: <b>AllergyIntolerance.reaction.exposureRoute</b><br> 2474 * </p> 2475 */ 2476 @SearchParamDefinition(name="route", path="AllergyIntolerance.reaction.exposureRoute", description="How the subject was exposed to the substance", type="token" ) 2477 public static final String SP_ROUTE = "route"; 2478 /** 2479 * <b>Fluent Client</b> search parameter constant for <b>route</b> 2480 * <p> 2481 * Description: <b>How the subject was exposed to the substance</b><br> 2482 * Type: <b>token</b><br> 2483 * Path: <b>AllergyIntolerance.reaction.exposureRoute</b><br> 2484 * </p> 2485 */ 2486 public static final ca.uhn.fhir.rest.gclient.TokenClientParam ROUTE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ROUTE); 2487 2488 /** 2489 * Search parameter: <b>severity</b> 2490 * <p> 2491 * Description: <b>mild | moderate | severe (of event as a whole)</b><br> 2492 * Type: <b>token</b><br> 2493 * Path: <b>AllergyIntolerance.reaction.severity</b><br> 2494 * </p> 2495 */ 2496 @SearchParamDefinition(name="severity", path="AllergyIntolerance.reaction.severity", description="mild | moderate | severe (of event as a whole)", type="token" ) 2497 public static final String SP_SEVERITY = "severity"; 2498 /** 2499 * <b>Fluent Client</b> search parameter constant for <b>severity</b> 2500 * <p> 2501 * Description: <b>mild | moderate | severe (of event as a whole)</b><br> 2502 * Type: <b>token</b><br> 2503 * Path: <b>AllergyIntolerance.reaction.severity</b><br> 2504 * </p> 2505 */ 2506 public static final ca.uhn.fhir.rest.gclient.TokenClientParam SEVERITY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SEVERITY); 2507 2508 /** 2509 * Search parameter: <b>verification-status</b> 2510 * <p> 2511 * Description: <b>unconfirmed | confirmed | refuted | entered-in-error</b><br> 2512 * Type: <b>token</b><br> 2513 * Path: <b>AllergyIntolerance.verificationStatus</b><br> 2514 * </p> 2515 */ 2516 @SearchParamDefinition(name="verification-status", path="AllergyIntolerance.verificationStatus", description="unconfirmed | confirmed | refuted | entered-in-error", type="token" ) 2517 public static final String SP_VERIFICATION_STATUS = "verification-status"; 2518 /** 2519 * <b>Fluent Client</b> search parameter constant for <b>verification-status</b> 2520 * <p> 2521 * Description: <b>unconfirmed | confirmed | refuted | entered-in-error</b><br> 2522 * Type: <b>token</b><br> 2523 * Path: <b>AllergyIntolerance.verificationStatus</b><br> 2524 * </p> 2525 */ 2526 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERIFICATION_STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERIFICATION_STATUS); 2527 2528 /** 2529 * Search parameter: <b>code</b> 2530 * <p> 2531 * Description: <b>Multiple Resources: 2532 2533* [AllergyIntolerance](allergyintolerance.html): Code that identifies the allergy or intolerance 2534* [Condition](condition.html): Code for the condition 2535* [DeviceRequest](devicerequest.html): Code for what is being requested/ordered 2536* [DiagnosticReport](diagnosticreport.html): The code for the report, as opposed to codes for the atomic results, which are the names on the observation resource referred to from the result 2537* [FamilyMemberHistory](familymemberhistory.html): A search by a condition code 2538* [List](list.html): What the purpose of this list is 2539* [Medication](medication.html): Returns medications for a specific code 2540* [MedicationAdministration](medicationadministration.html): Return administrations of this medication code 2541* [MedicationDispense](medicationdispense.html): Returns dispenses of this medicine code 2542* [MedicationRequest](medicationrequest.html): Return prescriptions of this medication code 2543* [MedicationStatement](medicationstatement.html): Return statements of this medication code 2544* [Observation](observation.html): The code of the observation type 2545* [Procedure](procedure.html): A code to identify a procedure 2546* [ServiceRequest](servicerequest.html): What is being requested/ordered 2547</b><br> 2548 * Type: <b>token</b><br> 2549 * Path: <b>AllergyIntolerance.code | AllergyIntolerance.reaction.substance | Condition.code | (DeviceRequest.code as CodeableConcept) | DiagnosticReport.code | FamilyMemberHistory.condition.code | List.code | Medication.code | (MedicationAdministration.medication as CodeableConcept) | (MedicationDispense.medication as CodeableConcept) | (MedicationRequest.medication as CodeableConcept) | (MedicationStatement.medication as CodeableConcept) | Observation.code | Procedure.code | ServiceRequest.code</b><br> 2550 * </p> 2551 */ 2552 @SearchParamDefinition(name="code", path="AllergyIntolerance.code | AllergyIntolerance.reaction.substance | Condition.code | (DeviceRequest.code as CodeableConcept) | DiagnosticReport.code | FamilyMemberHistory.condition.code | List.code | Medication.code | (MedicationAdministration.medication as CodeableConcept) | (MedicationDispense.medication as CodeableConcept) | (MedicationRequest.medication as CodeableConcept) | (MedicationStatement.medication as CodeableConcept) | Observation.code | Procedure.code | ServiceRequest.code", description="Multiple Resources: \r\n\r\n* [AllergyIntolerance](allergyintolerance.html): Code that identifies the allergy or intolerance\r\n* [Condition](condition.html): Code for the condition\r\n* [DeviceRequest](devicerequest.html): Code for what is being requested/ordered\r\n* [DiagnosticReport](diagnosticreport.html): The code for the report, as opposed to codes for the atomic results, which are the names on the observation resource referred to from the result\r\n* [FamilyMemberHistory](familymemberhistory.html): A search by a condition code\r\n* [List](list.html): What the purpose of this list is\r\n* [Medication](medication.html): Returns medications for a specific code\r\n* [MedicationAdministration](medicationadministration.html): Return administrations of this medication code\r\n* [MedicationDispense](medicationdispense.html): Returns dispenses of this medicine code\r\n* [MedicationRequest](medicationrequest.html): Return prescriptions of this medication code\r\n* [MedicationStatement](medicationstatement.html): Return statements of this medication code\r\n* [Observation](observation.html): The code of the observation type\r\n* [Procedure](procedure.html): A code to identify a procedure\r\n* [ServiceRequest](servicerequest.html): What is being requested/ordered\r\n", type="token" ) 2553 public static final String SP_CODE = "code"; 2554 /** 2555 * <b>Fluent Client</b> search parameter constant for <b>code</b> 2556 * <p> 2557 * Description: <b>Multiple Resources: 2558 2559* [AllergyIntolerance](allergyintolerance.html): Code that identifies the allergy or intolerance 2560* [Condition](condition.html): Code for the condition 2561* [DeviceRequest](devicerequest.html): Code for what is being requested/ordered 2562* [DiagnosticReport](diagnosticreport.html): The code for the report, as opposed to codes for the atomic results, which are the names on the observation resource referred to from the result 2563* [FamilyMemberHistory](familymemberhistory.html): A search by a condition code 2564* [List](list.html): What the purpose of this list is 2565* [Medication](medication.html): Returns medications for a specific code 2566* [MedicationAdministration](medicationadministration.html): Return administrations of this medication code 2567* [MedicationDispense](medicationdispense.html): Returns dispenses of this medicine code 2568* [MedicationRequest](medicationrequest.html): Return prescriptions of this medication code 2569* [MedicationStatement](medicationstatement.html): Return statements of this medication code 2570* [Observation](observation.html): The code of the observation type 2571* [Procedure](procedure.html): A code to identify a procedure 2572* [ServiceRequest](servicerequest.html): What is being requested/ordered 2573</b><br> 2574 * Type: <b>token</b><br> 2575 * Path: <b>AllergyIntolerance.code | AllergyIntolerance.reaction.substance | Condition.code | (DeviceRequest.code as CodeableConcept) | DiagnosticReport.code | FamilyMemberHistory.condition.code | List.code | Medication.code | (MedicationAdministration.medication as CodeableConcept) | (MedicationDispense.medication as CodeableConcept) | (MedicationRequest.medication as CodeableConcept) | (MedicationStatement.medication as CodeableConcept) | Observation.code | Procedure.code | ServiceRequest.code</b><br> 2576 * </p> 2577 */ 2578 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE); 2579 2580 /** 2581 * Search parameter: <b>date</b> 2582 * <p> 2583 * Description: <b>Multiple Resources: 2584 2585* [AllergyIntolerance](allergyintolerance.html): Date first version of the resource instance was recorded 2586* [CarePlan](careplan.html): Time period plan covers 2587* [CareTeam](careteam.html): Time period team covers 2588* [ClinicalImpression](clinicalimpression.html): When the assessment was documented 2589* [Composition](composition.html): Composition editing time 2590* [Consent](consent.html): When this Consent was created or indexed 2591* [DiagnosticReport](diagnosticreport.html): The clinically relevant time of the report 2592* [Encounter](encounter.html): A date within the period the Encounter lasted 2593* [EpisodeOfCare](episodeofcare.html): The provided date search value falls within the episode of care's period 2594* [FamilyMemberHistory](familymemberhistory.html): When history was recorded or last updated 2595* [Flag](flag.html): Time period when flag is active 2596* [Immunization](immunization.html): Vaccination (non)-Administration Date 2597* [List](list.html): When the list was prepared 2598* [Observation](observation.html): Obtained date/time. If the obtained element is a period, a date that falls in the period 2599* [Procedure](procedure.html): When the procedure was performed 2600* [RiskAssessment](riskassessment.html): When was assessment made? 2601* [SupplyRequest](supplyrequest.html): When the request was made 2602</b><br> 2603 * Type: <b>date</b><br> 2604 * Path: <b>AllergyIntolerance.recordedDate | CarePlan.period | CareTeam.period | ClinicalImpression.date | Composition.date | Consent.dateTime | DiagnosticReport.effective | Encounter.period | EpisodeOfCare.period | FamilyMemberHistory.date | Flag.period | Immunization.occurrence | List.date | Observation.effective | Procedure.performed | (RiskAssessment.occurrence as dateTime) | SupplyRequest.authoredOn</b><br> 2605 * </p> 2606 */ 2607 @SearchParamDefinition(name="date", path="AllergyIntolerance.recordedDate | CarePlan.period | CareTeam.period | ClinicalImpression.date | Composition.date | Consent.dateTime | DiagnosticReport.effective | Encounter.period | EpisodeOfCare.period | FamilyMemberHistory.date | Flag.period | Immunization.occurrence | List.date | Observation.effective | Procedure.performed | (RiskAssessment.occurrence as dateTime) | SupplyRequest.authoredOn", description="Multiple Resources: \r\n\r\n* [AllergyIntolerance](allergyintolerance.html): Date first version of the resource instance was recorded\r\n* [CarePlan](careplan.html): Time period plan covers\r\n* [CareTeam](careteam.html): Time period team covers\r\n* [ClinicalImpression](clinicalimpression.html): When the assessment was documented\r\n* [Composition](composition.html): Composition editing time\r\n* [Consent](consent.html): When this Consent was created or indexed\r\n* [DiagnosticReport](diagnosticreport.html): The clinically relevant time of the report\r\n* [Encounter](encounter.html): A date within the period the Encounter lasted\r\n* [EpisodeOfCare](episodeofcare.html): The provided date search value falls within the episode of care's period\r\n* [FamilyMemberHistory](familymemberhistory.html): When history was recorded or last updated\r\n* [Flag](flag.html): Time period when flag is active\r\n* [Immunization](immunization.html): Vaccination (non)-Administration Date\r\n* [List](list.html): When the list was prepared\r\n* [Observation](observation.html): Obtained date/time. If the obtained element is a period, a date that falls in the period\r\n* [Procedure](procedure.html): When the procedure was performed\r\n* [RiskAssessment](riskassessment.html): When was assessment made?\r\n* [SupplyRequest](supplyrequest.html): When the request was made\r\n", type="date" ) 2608 public static final String SP_DATE = "date"; 2609 /** 2610 * <b>Fluent Client</b> search parameter constant for <b>date</b> 2611 * <p> 2612 * Description: <b>Multiple Resources: 2613 2614* [AllergyIntolerance](allergyintolerance.html): Date first version of the resource instance was recorded 2615* [CarePlan](careplan.html): Time period plan covers 2616* [CareTeam](careteam.html): Time period team covers 2617* [ClinicalImpression](clinicalimpression.html): When the assessment was documented 2618* [Composition](composition.html): Composition editing time 2619* [Consent](consent.html): When this Consent was created or indexed 2620* [DiagnosticReport](diagnosticreport.html): The clinically relevant time of the report 2621* [Encounter](encounter.html): A date within the period the Encounter lasted 2622* [EpisodeOfCare](episodeofcare.html): The provided date search value falls within the episode of care's period 2623* [FamilyMemberHistory](familymemberhistory.html): When history was recorded or last updated 2624* [Flag](flag.html): Time period when flag is active 2625* [Immunization](immunization.html): Vaccination (non)-Administration Date 2626* [List](list.html): When the list was prepared 2627* [Observation](observation.html): Obtained date/time. If the obtained element is a period, a date that falls in the period 2628* [Procedure](procedure.html): When the procedure was performed 2629* [RiskAssessment](riskassessment.html): When was assessment made? 2630* [SupplyRequest](supplyrequest.html): When the request was made 2631</b><br> 2632 * Type: <b>date</b><br> 2633 * Path: <b>AllergyIntolerance.recordedDate | CarePlan.period | CareTeam.period | ClinicalImpression.date | Composition.date | Consent.dateTime | DiagnosticReport.effective | Encounter.period | EpisodeOfCare.period | FamilyMemberHistory.date | Flag.period | Immunization.occurrence | List.date | Observation.effective | Procedure.performed | (RiskAssessment.occurrence as dateTime) | SupplyRequest.authoredOn</b><br> 2634 * </p> 2635 */ 2636 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 2637 2638 /** 2639 * Search parameter: <b>identifier</b> 2640 * <p> 2641 * Description: <b>Multiple Resources: 2642 2643* [AllergyIntolerance](allergyintolerance.html): External ids for this item 2644* [CarePlan](careplan.html): External Ids for this plan 2645* [CareTeam](careteam.html): External Ids for this team 2646* [Composition](composition.html): Version-independent identifier for the Composition 2647* [Condition](condition.html): A unique identifier of the condition record 2648* [Consent](consent.html): Identifier for this record (external references) 2649* [DetectedIssue](detectedissue.html): Unique id for the detected issue 2650* [DeviceRequest](devicerequest.html): Business identifier for request/order 2651* [DiagnosticReport](diagnosticreport.html): An identifier for the report 2652* [DocumentManifest](documentmanifest.html): Unique Identifier for the set of documents 2653* [DocumentReference](documentreference.html): Master Version Specific Identifier 2654* [Encounter](encounter.html): Identifier(s) by which this encounter is known 2655* [EpisodeOfCare](episodeofcare.html): Business Identifier(s) relevant for this EpisodeOfCare 2656* [FamilyMemberHistory](familymemberhistory.html): A search by a record identifier 2657* [Goal](goal.html): External Ids for this goal 2658* [ImagingStudy](imagingstudy.html): Identifiers for the Study, such as DICOM Study Instance UID and Accession number 2659* [Immunization](immunization.html): Business identifier 2660* [List](list.html): Business identifier 2661* [MedicationAdministration](medicationadministration.html): Return administrations with this external identifier 2662* [MedicationDispense](medicationdispense.html): Returns dispenses with this external identifier 2663* [MedicationRequest](medicationrequest.html): Return prescriptions with this external identifier 2664* [MedicationStatement](medicationstatement.html): Return statements with this external identifier 2665* [NutritionOrder](nutritionorder.html): Return nutrition orders with this external identifier 2666* [Observation](observation.html): The unique id for a particular observation 2667* [Procedure](procedure.html): A unique identifier for a procedure 2668* [RiskAssessment](riskassessment.html): Unique identifier for the assessment 2669* [ServiceRequest](servicerequest.html): Identifiers assigned to this order 2670* [SupplyDelivery](supplydelivery.html): External identifier 2671* [SupplyRequest](supplyrequest.html): Business Identifier for SupplyRequest 2672* [VisionPrescription](visionprescription.html): Return prescriptions with this external identifier 2673</b><br> 2674 * Type: <b>token</b><br> 2675 * Path: <b>AllergyIntolerance.identifier | CarePlan.identifier | CareTeam.identifier | Composition.identifier | Condition.identifier | Consent.identifier | DetectedIssue.identifier | DeviceRequest.identifier | DiagnosticReport.identifier | DocumentManifest.masterIdentifier | DocumentManifest.identifier | DocumentReference.masterIdentifier | DocumentReference.identifier | Encounter.identifier | EpisodeOfCare.identifier | FamilyMemberHistory.identifier | Goal.identifier | ImagingStudy.identifier | Immunization.identifier | List.identifier | MedicationAdministration.identifier | MedicationDispense.identifier | MedicationRequest.identifier | MedicationStatement.identifier | NutritionOrder.identifier | Observation.identifier | Procedure.identifier | RiskAssessment.identifier | ServiceRequest.identifier | SupplyDelivery.identifier | SupplyRequest.identifier | VisionPrescription.identifier</b><br> 2676 * </p> 2677 */ 2678 @SearchParamDefinition(name="identifier", path="AllergyIntolerance.identifier | CarePlan.identifier | CareTeam.identifier | Composition.identifier | Condition.identifier | Consent.identifier | DetectedIssue.identifier | DeviceRequest.identifier | DiagnosticReport.identifier | DocumentManifest.masterIdentifier | DocumentManifest.identifier | DocumentReference.masterIdentifier | DocumentReference.identifier | Encounter.identifier | EpisodeOfCare.identifier | FamilyMemberHistory.identifier | Goal.identifier | ImagingStudy.identifier | Immunization.identifier | List.identifier | MedicationAdministration.identifier | MedicationDispense.identifier | MedicationRequest.identifier | MedicationStatement.identifier | NutritionOrder.identifier | Observation.identifier | Procedure.identifier | RiskAssessment.identifier | ServiceRequest.identifier | SupplyDelivery.identifier | SupplyRequest.identifier | VisionPrescription.identifier", description="Multiple Resources: \r\n\r\n* [AllergyIntolerance](allergyintolerance.html): External ids for this item\r\n* [CarePlan](careplan.html): External Ids for this plan\r\n* [CareTeam](careteam.html): External Ids for this team\r\n* [Composition](composition.html): Version-independent identifier for the Composition\r\n* [Condition](condition.html): A unique identifier of the condition record\r\n* [Consent](consent.html): Identifier for this record (external references)\r\n* [DetectedIssue](detectedissue.html): Unique id for the detected issue\r\n* [DeviceRequest](devicerequest.html): Business identifier for request/order\r\n* [DiagnosticReport](diagnosticreport.html): An identifier for the report\r\n* [DocumentManifest](documentmanifest.html): Unique Identifier for the set of documents\r\n* [DocumentReference](documentreference.html): Master Version Specific Identifier\r\n* [Encounter](encounter.html): Identifier(s) by which this encounter is known\r\n* [EpisodeOfCare](episodeofcare.html): Business Identifier(s) relevant for this EpisodeOfCare\r\n* [FamilyMemberHistory](familymemberhistory.html): A search by a record identifier\r\n* [Goal](goal.html): External Ids for this goal\r\n* [ImagingStudy](imagingstudy.html): Identifiers for the Study, such as DICOM Study Instance UID and Accession number\r\n* [Immunization](immunization.html): Business identifier\r\n* [List](list.html): Business identifier\r\n* [MedicationAdministration](medicationadministration.html): Return administrations with this external identifier\r\n* [MedicationDispense](medicationdispense.html): Returns dispenses with this external identifier\r\n* [MedicationRequest](medicationrequest.html): Return prescriptions with this external identifier\r\n* [MedicationStatement](medicationstatement.html): Return statements with this external identifier\r\n* [NutritionOrder](nutritionorder.html): Return nutrition orders with this external identifier\r\n* [Observation](observation.html): The unique id for a particular observation\r\n* [Procedure](procedure.html): A unique identifier for a procedure\r\n* [RiskAssessment](riskassessment.html): Unique identifier for the assessment\r\n* [ServiceRequest](servicerequest.html): Identifiers assigned to this order\r\n* [SupplyDelivery](supplydelivery.html): External identifier\r\n* [SupplyRequest](supplyrequest.html): Business Identifier for SupplyRequest\r\n* [VisionPrescription](visionprescription.html): Return prescriptions with this external identifier\r\n", type="token" ) 2679 public static final String SP_IDENTIFIER = "identifier"; 2680 /** 2681 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 2682 * <p> 2683 * Description: <b>Multiple Resources: 2684 2685* [AllergyIntolerance](allergyintolerance.html): External ids for this item 2686* [CarePlan](careplan.html): External Ids for this plan 2687* [CareTeam](careteam.html): External Ids for this team 2688* [Composition](composition.html): Version-independent identifier for the Composition 2689* [Condition](condition.html): A unique identifier of the condition record 2690* [Consent](consent.html): Identifier for this record (external references) 2691* [DetectedIssue](detectedissue.html): Unique id for the detected issue 2692* [DeviceRequest](devicerequest.html): Business identifier for request/order 2693* [DiagnosticReport](diagnosticreport.html): An identifier for the report 2694* [DocumentManifest](documentmanifest.html): Unique Identifier for the set of documents 2695* [DocumentReference](documentreference.html): Master Version Specific Identifier 2696* [Encounter](encounter.html): Identifier(s) by which this encounter is known 2697* [EpisodeOfCare](episodeofcare.html): Business Identifier(s) relevant for this EpisodeOfCare 2698* [FamilyMemberHistory](familymemberhistory.html): A search by a record identifier 2699* [Goal](goal.html): External Ids for this goal 2700* [ImagingStudy](imagingstudy.html): Identifiers for the Study, such as DICOM Study Instance UID and Accession number 2701* [Immunization](immunization.html): Business identifier 2702* [List](list.html): Business identifier 2703* [MedicationAdministration](medicationadministration.html): Return administrations with this external identifier 2704* [MedicationDispense](medicationdispense.html): Returns dispenses with this external identifier 2705* [MedicationRequest](medicationrequest.html): Return prescriptions with this external identifier 2706* [MedicationStatement](medicationstatement.html): Return statements with this external identifier 2707* [NutritionOrder](nutritionorder.html): Return nutrition orders with this external identifier 2708* [Observation](observation.html): The unique id for a particular observation 2709* [Procedure](procedure.html): A unique identifier for a procedure 2710* [RiskAssessment](riskassessment.html): Unique identifier for the assessment 2711* [ServiceRequest](servicerequest.html): Identifiers assigned to this order 2712* [SupplyDelivery](supplydelivery.html): External identifier 2713* [SupplyRequest](supplyrequest.html): Business Identifier for SupplyRequest 2714* [VisionPrescription](visionprescription.html): Return prescriptions with this external identifier 2715</b><br> 2716 * Type: <b>token</b><br> 2717 * Path: <b>AllergyIntolerance.identifier | CarePlan.identifier | CareTeam.identifier | Composition.identifier | Condition.identifier | Consent.identifier | DetectedIssue.identifier | DeviceRequest.identifier | DiagnosticReport.identifier | DocumentManifest.masterIdentifier | DocumentManifest.identifier | DocumentReference.masterIdentifier | DocumentReference.identifier | Encounter.identifier | EpisodeOfCare.identifier | FamilyMemberHistory.identifier | Goal.identifier | ImagingStudy.identifier | Immunization.identifier | List.identifier | MedicationAdministration.identifier | MedicationDispense.identifier | MedicationRequest.identifier | MedicationStatement.identifier | NutritionOrder.identifier | Observation.identifier | Procedure.identifier | RiskAssessment.identifier | ServiceRequest.identifier | SupplyDelivery.identifier | SupplyRequest.identifier | VisionPrescription.identifier</b><br> 2718 * </p> 2719 */ 2720 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 2721 2722 /** 2723 * Search parameter: <b>patient</b> 2724 * <p> 2725 * Description: <b>Multiple Resources: 2726 2727* [AllergyIntolerance](allergyintolerance.html): Who the sensitivity is for 2728* [CarePlan](careplan.html): Who the care plan is for 2729* [CareTeam](careteam.html): Who care team is for 2730* [ClinicalImpression](clinicalimpression.html): Patient or group assessed 2731* [Composition](composition.html): Who and/or what the composition is about 2732* [Condition](condition.html): Who has the condition? 2733* [Consent](consent.html): Who the consent applies to 2734* [DetectedIssue](detectedissue.html): Associated patient 2735* [DeviceRequest](devicerequest.html): Individual the service is ordered for 2736* [DeviceUseStatement](deviceusestatement.html): Search by subject - a patient 2737* [DiagnosticReport](diagnosticreport.html): The subject of the report if a patient 2738* [DocumentManifest](documentmanifest.html): The subject of the set of documents 2739* [DocumentReference](documentreference.html): Who/what is the subject of the document 2740* [Encounter](encounter.html): The patient or group present at the encounter 2741* [EpisodeOfCare](episodeofcare.html): The patient who is the focus of this episode of care 2742* [FamilyMemberHistory](familymemberhistory.html): The identity of a subject to list family member history items for 2743* [Flag](flag.html): The identity of a subject to list flags for 2744* [Goal](goal.html): Who this goal is intended for 2745* [ImagingStudy](imagingstudy.html): Who the study is about 2746* [Immunization](immunization.html): The patient for the vaccination record 2747* [List](list.html): If all resources have the same subject 2748* [MedicationAdministration](medicationadministration.html): The identity of a patient to list administrations for 2749* [MedicationDispense](medicationdispense.html): The identity of a patient to list dispenses for 2750* [MedicationRequest](medicationrequest.html): Returns prescriptions for a specific patient 2751* [MedicationStatement](medicationstatement.html): Returns statements for a specific patient. 2752* [NutritionOrder](nutritionorder.html): The identity of the person who requires the diet, formula or nutritional supplement 2753* [Observation](observation.html): The subject that the observation is about (if patient) 2754* [Procedure](procedure.html): Search by subject - a patient 2755* [RiskAssessment](riskassessment.html): Who/what does assessment apply to? 2756* [ServiceRequest](servicerequest.html): Search by subject - a patient 2757* [SupplyDelivery](supplydelivery.html): Patient for whom the item is supplied 2758* [VisionPrescription](visionprescription.html): The identity of a patient to list dispenses for 2759</b><br> 2760 * Type: <b>reference</b><br> 2761 * Path: <b>AllergyIntolerance.patient | CarePlan.subject.where(resolve() is Patient) | CareTeam.subject.where(resolve() is Patient) | ClinicalImpression.subject.where(resolve() is Patient) | Composition.subject.where(resolve() is Patient) | Condition.subject.where(resolve() is Patient) | Consent.patient | DetectedIssue.patient | DeviceRequest.subject.where(resolve() is Patient) | DeviceUseStatement.subject.where(resolve() is Patient) | DiagnosticReport.subject.where(resolve() is Patient) | DocumentManifest.subject.where(resolve() is Patient) | DocumentReference.subject.where(resolve() is Patient) | Encounter.subject.where(resolve() is Patient) | EpisodeOfCare.patient | FamilyMemberHistory.patient | Flag.subject.where(resolve() is Patient) | Goal.subject.where(resolve() is Patient) | ImagingStudy.subject.where(resolve() is Patient) | Immunization.patient | List.subject.where(resolve() is Patient) | MedicationAdministration.subject.where(resolve() is Patient) | MedicationDispense.subject.where(resolve() is Patient) | MedicationRequest.subject.where(resolve() is Patient) | MedicationStatement.subject.where(resolve() is Patient) | NutritionOrder.patient | Observation.subject.where(resolve() is Patient) | Procedure.subject.where(resolve() is Patient) | RiskAssessment.subject.where(resolve() is Patient) | ServiceRequest.subject.where(resolve() is Patient) | SupplyDelivery.patient | VisionPrescription.patient</b><br> 2762 * </p> 2763 */ 2764 @SearchParamDefinition(name="patient", path="AllergyIntolerance.patient | CarePlan.subject.where(resolve() is Patient) | CareTeam.subject.where(resolve() is Patient) | ClinicalImpression.subject.where(resolve() is Patient) | Composition.subject.where(resolve() is Patient) | Condition.subject.where(resolve() is Patient) | Consent.patient | DetectedIssue.patient | DeviceRequest.subject.where(resolve() is Patient) | DeviceUseStatement.subject.where(resolve() is Patient) | DiagnosticReport.subject.where(resolve() is Patient) | DocumentManifest.subject.where(resolve() is Patient) | DocumentReference.subject.where(resolve() is Patient) | Encounter.subject.where(resolve() is Patient) | EpisodeOfCare.patient | FamilyMemberHistory.patient | Flag.subject.where(resolve() is Patient) | Goal.subject.where(resolve() is Patient) | ImagingStudy.subject.where(resolve() is Patient) | Immunization.patient | List.subject.where(resolve() is Patient) | MedicationAdministration.subject.where(resolve() is Patient) | MedicationDispense.subject.where(resolve() is Patient) | MedicationRequest.subject.where(resolve() is Patient) | MedicationStatement.subject.where(resolve() is Patient) | NutritionOrder.patient | Observation.subject.where(resolve() is Patient) | Procedure.subject.where(resolve() is Patient) | RiskAssessment.subject.where(resolve() is Patient) | ServiceRequest.subject.where(resolve() is Patient) | SupplyDelivery.patient | VisionPrescription.patient", description="Multiple Resources: \r\n\r\n* [AllergyIntolerance](allergyintolerance.html): Who the sensitivity is for\r\n* [CarePlan](careplan.html): Who the care plan is for\r\n* [CareTeam](careteam.html): Who care team is for\r\n* [ClinicalImpression](clinicalimpression.html): Patient or group assessed\r\n* [Composition](composition.html): Who and/or what the composition is about\r\n* [Condition](condition.html): Who has the condition?\r\n* [Consent](consent.html): Who the consent applies to\r\n* [DetectedIssue](detectedissue.html): Associated patient\r\n* [DeviceRequest](devicerequest.html): Individual the service is ordered for\r\n* [DeviceUseStatement](deviceusestatement.html): Search by subject - a patient\r\n* [DiagnosticReport](diagnosticreport.html): The subject of the report if a patient\r\n* [DocumentManifest](documentmanifest.html): The subject of the set of documents\r\n* [DocumentReference](documentreference.html): Who/what is the subject of the document\r\n* [Encounter](encounter.html): The patient or group present at the encounter\r\n* [EpisodeOfCare](episodeofcare.html): The patient who is the focus of this episode of care\r\n* [FamilyMemberHistory](familymemberhistory.html): The identity of a subject to list family member history items for\r\n* [Flag](flag.html): The identity of a subject to list flags for\r\n* [Goal](goal.html): Who this goal is intended for\r\n* [ImagingStudy](imagingstudy.html): Who the study is about\r\n* [Immunization](immunization.html): The patient for the vaccination record\r\n* [List](list.html): If all resources have the same subject\r\n* [MedicationAdministration](medicationadministration.html): The identity of a patient to list administrations for\r\n* [MedicationDispense](medicationdispense.html): The identity of a patient to list dispenses for\r\n* [MedicationRequest](medicationrequest.html): Returns prescriptions for a specific patient\r\n* [MedicationStatement](medicationstatement.html): Returns statements for a specific patient.\r\n* [NutritionOrder](nutritionorder.html): The identity of the person who requires the diet, formula or nutritional supplement\r\n* [Observation](observation.html): The subject that the observation is about (if patient)\r\n* [Procedure](procedure.html): Search by subject - a patient\r\n* [RiskAssessment](riskassessment.html): Who/what does assessment apply to?\r\n* [ServiceRequest](servicerequest.html): Search by subject - a patient\r\n* [SupplyDelivery](supplydelivery.html): Patient for whom the item is supplied\r\n* [VisionPrescription](visionprescription.html): The identity of a patient to list dispenses for\r\n", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Base FHIR compartment definition for Patient") }, target={Account.class, ActivityDefinition.class, AdministrableProductDefinition.class, AdverseEvent.class, AllergyIntolerance.class, Appointment.class, AppointmentResponse.class, AuditEvent.class, Basic.class, Binary.class, BiologicallyDerivedProduct.class, BodyStructure.class, Bundle.class, CapabilityStatement.class, CarePlan.class, CareTeam.class, CatalogEntry.class, ChargeItem.class, ChargeItemDefinition.class, Citation.class, Claim.class, ClaimResponse.class, ClinicalImpression.class, ClinicalUseDefinition.class, CodeSystem.class, Communication.class, CommunicationRequest.class, CompartmentDefinition.class, Composition.class, ConceptMap.class, Condition.class, Consent.class, Contract.class, Coverage.class, CoverageEligibilityRequest.class, CoverageEligibilityResponse.class, DetectedIssue.class, Device.class, DeviceDefinition.class, DeviceMetric.class, DeviceRequest.class, DeviceUseStatement.class, DiagnosticReport.class, DocumentManifest.class, DocumentReference.class, Encounter.class, Endpoint.class, EnrollmentRequest.class, EnrollmentResponse.class, EpisodeOfCare.class, EventDefinition.class, Evidence.class, EvidenceReport.class, EvidenceVariable.class, ExampleScenario.class, ExplanationOfBenefit.class, FamilyMemberHistory.class, Flag.class, Goal.class, GraphDefinition.class, Group.class, GuidanceResponse.class, HealthcareService.class, ImagingStudy.class, Immunization.class, ImmunizationEvaluation.class, ImmunizationRecommendation.class, ImplementationGuide.class, Ingredient.class, InsurancePlan.class, Invoice.class, Library.class, Linkage.class, ListResource.class, Location.class, ManufacturedItemDefinition.class, Measure.class, MeasureReport.class, Media.class, Medication.class, MedicationAdministration.class, MedicationDispense.class, MedicationKnowledge.class, MedicationRequest.class, MedicationStatement.class, MedicinalProductDefinition.class, MessageDefinition.class, MessageHeader.class, MolecularSequence.class, NamingSystem.class, NutritionOrder.class, NutritionProduct.class, Observation.class, ObservationDefinition.class, OperationDefinition.class, OperationOutcome.class, Organization.class, OrganizationAffiliation.class, PackagedProductDefinition.class, Patient.class, PaymentNotice.class, PaymentReconciliation.class, Person.class, PlanDefinition.class, Practitioner.class, PractitionerRole.class, Procedure.class, Provenance.class, Questionnaire.class, QuestionnaireResponse.class, RegulatedAuthorization.class, RelatedPerson.class, RequestGroup.class, ResearchDefinition.class, ResearchElementDefinition.class, ResearchStudy.class, ResearchSubject.class, RiskAssessment.class, Schedule.class, SearchParameter.class, ServiceRequest.class, Slot.class, Specimen.class, SpecimenDefinition.class, StructureDefinition.class, StructureMap.class, Subscription.class, SubscriptionStatus.class, SubscriptionTopic.class, Substance.class, SubstanceDefinition.class, SupplyDelivery.class, SupplyRequest.class, Task.class, TerminologyCapabilities.class, TestReport.class, TestScript.class, ValueSet.class, VerificationResult.class, VisionPrescription.class } ) 2765 public static final String SP_PATIENT = "patient"; 2766 /** 2767 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 2768 * <p> 2769 * Description: <b>Multiple Resources: 2770 2771* [AllergyIntolerance](allergyintolerance.html): Who the sensitivity is for 2772* [CarePlan](careplan.html): Who the care plan is for 2773* [CareTeam](careteam.html): Who care team is for 2774* [ClinicalImpression](clinicalimpression.html): Patient or group assessed 2775* [Composition](composition.html): Who and/or what the composition is about 2776* [Condition](condition.html): Who has the condition? 2777* [Consent](consent.html): Who the consent applies to 2778* [DetectedIssue](detectedissue.html): Associated patient 2779* [DeviceRequest](devicerequest.html): Individual the service is ordered for 2780* [DeviceUseStatement](deviceusestatement.html): Search by subject - a patient 2781* [DiagnosticReport](diagnosticreport.html): The subject of the report if a patient 2782* [DocumentManifest](documentmanifest.html): The subject of the set of documents 2783* [DocumentReference](documentreference.html): Who/what is the subject of the document 2784* [Encounter](encounter.html): The patient or group present at the encounter 2785* [EpisodeOfCare](episodeofcare.html): The patient who is the focus of this episode of care 2786* [FamilyMemberHistory](familymemberhistory.html): The identity of a subject to list family member history items for 2787* [Flag](flag.html): The identity of a subject to list flags for 2788* [Goal](goal.html): Who this goal is intended for 2789* [ImagingStudy](imagingstudy.html): Who the study is about 2790* [Immunization](immunization.html): The patient for the vaccination record 2791* [List](list.html): If all resources have the same subject 2792* [MedicationAdministration](medicationadministration.html): The identity of a patient to list administrations for 2793* [MedicationDispense](medicationdispense.html): The identity of a patient to list dispenses for 2794* [MedicationRequest](medicationrequest.html): Returns prescriptions for a specific patient 2795* [MedicationStatement](medicationstatement.html): Returns statements for a specific patient. 2796* [NutritionOrder](nutritionorder.html): The identity of the person who requires the diet, formula or nutritional supplement 2797* [Observation](observation.html): The subject that the observation is about (if patient) 2798* [Procedure](procedure.html): Search by subject - a patient 2799* [RiskAssessment](riskassessment.html): Who/what does assessment apply to? 2800* [ServiceRequest](servicerequest.html): Search by subject - a patient 2801* [SupplyDelivery](supplydelivery.html): Patient for whom the item is supplied 2802* [VisionPrescription](visionprescription.html): The identity of a patient to list dispenses for 2803</b><br> 2804 * Type: <b>reference</b><br> 2805 * Path: <b>AllergyIntolerance.patient | CarePlan.subject.where(resolve() is Patient) | CareTeam.subject.where(resolve() is Patient) | ClinicalImpression.subject.where(resolve() is Patient) | Composition.subject.where(resolve() is Patient) | Condition.subject.where(resolve() is Patient) | Consent.patient | DetectedIssue.patient | DeviceRequest.subject.where(resolve() is Patient) | DeviceUseStatement.subject.where(resolve() is Patient) | DiagnosticReport.subject.where(resolve() is Patient) | DocumentManifest.subject.where(resolve() is Patient) | DocumentReference.subject.where(resolve() is Patient) | Encounter.subject.where(resolve() is Patient) | EpisodeOfCare.patient | FamilyMemberHistory.patient | Flag.subject.where(resolve() is Patient) | Goal.subject.where(resolve() is Patient) | ImagingStudy.subject.where(resolve() is Patient) | Immunization.patient | List.subject.where(resolve() is Patient) | MedicationAdministration.subject.where(resolve() is Patient) | MedicationDispense.subject.where(resolve() is Patient) | MedicationRequest.subject.where(resolve() is Patient) | MedicationStatement.subject.where(resolve() is Patient) | NutritionOrder.patient | Observation.subject.where(resolve() is Patient) | Procedure.subject.where(resolve() is Patient) | RiskAssessment.subject.where(resolve() is Patient) | ServiceRequest.subject.where(resolve() is Patient) | SupplyDelivery.patient | VisionPrescription.patient</b><br> 2806 * </p> 2807 */ 2808 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT); 2809 2810/** 2811 * Constant for fluent queries to be used to add include statements. Specifies 2812 * the path value of "<b>AllergyIntolerance:patient</b>". 2813 */ 2814 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("AllergyIntolerance:patient").toLocked(); 2815 2816 /** 2817 * Search parameter: <b>type</b> 2818 * <p> 2819 * Description: <b>Multiple Resources: 2820 2821* [AllergyIntolerance](allergyintolerance.html): allergy | intolerance - Underlying mechanism (if known) 2822* [Composition](composition.html): Kind of composition (LOINC if possible) 2823* [DocumentManifest](documentmanifest.html): Kind of document set 2824* [DocumentReference](documentreference.html): Kind of document (LOINC if possible) 2825* [Encounter](encounter.html): Specific type of encounter 2826* [EpisodeOfCare](episodeofcare.html): Type/class - e.g. specialist referral, disease management 2827</b><br> 2828 * Type: <b>token</b><br> 2829 * Path: <b>AllergyIntolerance.type | Composition.type | DocumentManifest.type | DocumentReference.type | Encounter.type | EpisodeOfCare.type</b><br> 2830 * </p> 2831 */ 2832 @SearchParamDefinition(name="type", path="AllergyIntolerance.type | Composition.type | DocumentManifest.type | DocumentReference.type | Encounter.type | EpisodeOfCare.type", description="Multiple Resources: \r\n\r\n* [AllergyIntolerance](allergyintolerance.html): allergy | intolerance - Underlying mechanism (if known)\r\n* [Composition](composition.html): Kind of composition (LOINC if possible)\r\n* [DocumentManifest](documentmanifest.html): Kind of document set\r\n* [DocumentReference](documentreference.html): Kind of document (LOINC if possible)\r\n* [Encounter](encounter.html): Specific type of encounter\r\n* [EpisodeOfCare](episodeofcare.html): Type/class - e.g. specialist referral, disease management\r\n", type="token" ) 2833 public static final String SP_TYPE = "type"; 2834 /** 2835 * <b>Fluent Client</b> search parameter constant for <b>type</b> 2836 * <p> 2837 * Description: <b>Multiple Resources: 2838 2839* [AllergyIntolerance](allergyintolerance.html): allergy | intolerance - Underlying mechanism (if known) 2840* [Composition](composition.html): Kind of composition (LOINC if possible) 2841* [DocumentManifest](documentmanifest.html): Kind of document set 2842* [DocumentReference](documentreference.html): Kind of document (LOINC if possible) 2843* [Encounter](encounter.html): Specific type of encounter 2844* [EpisodeOfCare](episodeofcare.html): Type/class - e.g. specialist referral, disease management 2845</b><br> 2846 * Type: <b>token</b><br> 2847 * Path: <b>AllergyIntolerance.type | Composition.type | DocumentManifest.type | DocumentReference.type | Encounter.type | EpisodeOfCare.type</b><br> 2848 * </p> 2849 */ 2850 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE); 2851 2852 2853} 2854