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