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