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