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