001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
033
034import java.util.ArrayList;
035import java.util.Date;
036import java.util.List;
037import org.hl7.fhir.utilities.Utilities;
038import org.hl7.fhir.r5.model.Enumerations.*;
039import org.hl7.fhir.instance.model.api.IBaseDatatypeElement;
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.instance.model.api.ICompositeType;
042import ca.uhn.fhir.model.api.annotation.Child;
043import ca.uhn.fhir.model.api.annotation.ChildOrder;
044import ca.uhn.fhir.model.api.annotation.DatatypeDef;
045import ca.uhn.fhir.model.api.annotation.Description;
046import ca.uhn.fhir.model.api.annotation.Block;
047
048import org.hl7.fhir.instance.model.api.ICompositeType;
049import  org.hl7.fhir.r5.model.Enumerations.BindingStrength;
050import  org.hl7.fhir.r5.model.Enumerations.BindingStrengthEnumFactory;
051import  org.hl7.fhir.r5.utils.ToolingExtensions;
052import  org.hl7.fhir.instance.model.api.IBaseDatatypeElement;
053import  org.hl7.fhir.utilities.CommaSeparatedStringBuilder;
054/**
055 * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension.
056 */
057@DatatypeDef(name="ElementDefinition")
058public class ElementDefinition extends BackboneType implements ICompositeType {
059
060    public enum AdditionalBindingPurposeVS {
061        /**
062         * A required binding, for use when the binding strength is 'extensible' or 'preferred'
063         */
064        MAXIMUM, 
065        /**
066         * The minimum allowable value set - any conformant system SHALL support all these codes
067         */
068        MINIMUM, 
069        /**
070         * This value set is used as a required binding (in addition to the base binding (not a replacement), usually in a particular usage context)
071         */
072        REQUIRED, 
073        /**
074         * This value set is used as an extensible binding (in addition to the base binding (not a replacement), usually in a particular usage context)
075         */
076        EXTENSIBLE, 
077        /**
078         * This value set is a candidate to substitute for the overall conformance value set in some situations; usually these are defined in the documentation
079         */
080        CANDIDATE, 
081        /**
082         * New records are required to use this value set, but legacy records may use other codes. The definition of 'new record' is difficult, since systems often create new records based on pre-existing data. Usually 'current' bindings are mandated by an external authority that makes clear rules around this
083         */
084        CURRENT, 
085        /**
086         * This is the value set that is preferred in a given context (documentation should explain why)
087         */
088        PREFERRED, 
089        /**
090         * This value set is provided for user look up in a given context. Typically, these valuesets only include a subset of codes relevant for input in a context
091         */
092        UI, 
093        /**
094         * This value set is a good set of codes to start with when designing your system
095         */
096        STARTER, 
097        /**
098         * This value set is a component of the base value set. Usually this is called out so that documentation can be written about a portion of the value set
099         */
100        COMPONENT, 
101        /**
102         * added to help the parsers with the generic types
103         */
104        NULL;
105        public static AdditionalBindingPurposeVS fromCode(String codeString) throws FHIRException {
106            if (codeString == null || "".equals(codeString))
107                return null;
108        if ("maximum".equals(codeString))
109          return MAXIMUM;
110        if ("minimum".equals(codeString))
111          return MINIMUM;
112        if ("required".equals(codeString))
113          return REQUIRED;
114        if ("extensible".equals(codeString))
115          return EXTENSIBLE;
116        if ("candidate".equals(codeString))
117          return CANDIDATE;
118        if ("current".equals(codeString))
119          return CURRENT;
120        if ("preferred".equals(codeString))
121          return PREFERRED;
122        if ("ui".equals(codeString))
123          return UI;
124        if ("starter".equals(codeString))
125          return STARTER;
126        if ("component".equals(codeString))
127          return COMPONENT;
128        if (Configuration.isAcceptInvalidEnums())
129          return null;
130        else
131          throw new FHIRException("Unknown AdditionalBindingPurposeVS code '"+codeString+"'");
132        }
133        public String toCode() {
134          switch (this) {
135            case MAXIMUM: return "maximum";
136            case MINIMUM: return "minimum";
137            case REQUIRED: return "required";
138            case EXTENSIBLE: return "extensible";
139            case CANDIDATE: return "candidate";
140            case CURRENT: return "current";
141            case PREFERRED: return "preferred";
142            case UI: return "ui";
143            case STARTER: return "starter";
144            case COMPONENT: return "component";
145            case NULL: return null;
146            default: return "?";
147          }
148        }
149        public String getSystem() {
150          switch (this) {
151            case MAXIMUM: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
152            case MINIMUM: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
153            case REQUIRED: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
154            case EXTENSIBLE: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
155            case CANDIDATE: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
156            case CURRENT: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
157            case PREFERRED: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
158            case UI: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
159            case STARTER: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
160            case COMPONENT: return "http://hl7.org/fhir/CodeSystem/additional-binding-purpose";
161            case NULL: return null;
162            default: return "?";
163          }
164        }
165        public String getDefinition() {
166          switch (this) {
167            case MAXIMUM: return "A required binding, for use when the binding strength is 'extensible' or 'preferred'";
168            case MINIMUM: return "The minimum allowable value set - any conformant system SHALL support all these codes";
169            case REQUIRED: return "This value set is used as a required binding (in addition to the base binding (not a replacement), usually in a particular usage context)";
170            case EXTENSIBLE: return "This value set is used as an extensible binding (in addition to the base binding (not a replacement), usually in a particular usage context)";
171            case CANDIDATE: return "This value set is a candidate to substitute for the overall conformance value set in some situations; usually these are defined in the documentation";
172            case CURRENT: return "New records are required to use this value set, but legacy records may use other codes. The definition of 'new record' is difficult, since systems often create new records based on pre-existing data. Usually 'current' bindings are mandated by an external authority that makes clear rules around this";
173            case PREFERRED: return "This is the value set that is preferred in a given context (documentation should explain why)";
174            case UI: return "This value set is provided for user look up in a given context. Typically, these valuesets only include a subset of codes relevant for input in a context";
175            case STARTER: return "This value set is a good set of codes to start with when designing your system";
176            case COMPONENT: return "This value set is a component of the base value set. Usually this is called out so that documentation can be written about a portion of the value set";
177            case NULL: return null;
178            default: return "?";
179          }
180        }
181        public String getDisplay() {
182          switch (this) {
183            case MAXIMUM: return "Maximum Binding";
184            case MINIMUM: return "Minimum Binding";
185            case REQUIRED: return "Required Binding";
186            case EXTENSIBLE: return "Conformance Binding";
187            case CANDIDATE: return "Candidate Binding";
188            case CURRENT: return "Current Binding";
189            case PREFERRED: return "Preferred Binding";
190            case UI: return "UI Suggested Binding";
191            case STARTER: return "Starter Binding";
192            case COMPONENT: return "Component Binding";
193            case NULL: return null;
194            default: return "?";
195          }
196        }
197    }
198
199  public static class AdditionalBindingPurposeVSEnumFactory implements EnumFactory<AdditionalBindingPurposeVS> {
200    public AdditionalBindingPurposeVS fromCode(String codeString) throws IllegalArgumentException {
201      if (codeString == null || "".equals(codeString))
202            if (codeString == null || "".equals(codeString))
203                return null;
204        if ("maximum".equals(codeString))
205          return AdditionalBindingPurposeVS.MAXIMUM;
206        if ("minimum".equals(codeString))
207          return AdditionalBindingPurposeVS.MINIMUM;
208        if ("required".equals(codeString))
209          return AdditionalBindingPurposeVS.REQUIRED;
210        if ("extensible".equals(codeString))
211          return AdditionalBindingPurposeVS.EXTENSIBLE;
212        if ("candidate".equals(codeString))
213          return AdditionalBindingPurposeVS.CANDIDATE;
214        if ("current".equals(codeString))
215          return AdditionalBindingPurposeVS.CURRENT;
216        if ("preferred".equals(codeString))
217          return AdditionalBindingPurposeVS.PREFERRED;
218        if ("ui".equals(codeString))
219          return AdditionalBindingPurposeVS.UI;
220        if ("starter".equals(codeString))
221          return AdditionalBindingPurposeVS.STARTER;
222        if ("component".equals(codeString))
223          return AdditionalBindingPurposeVS.COMPONENT;
224        throw new IllegalArgumentException("Unknown AdditionalBindingPurposeVS code '"+codeString+"'");
225        }
226        public Enumeration<AdditionalBindingPurposeVS> fromType(PrimitiveType<?> code) throws FHIRException {
227          if (code == null)
228            return null;
229          if (code.isEmpty())
230            return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.NULL, code);
231          String codeString = ((PrimitiveType) code).asStringValue();
232          if (codeString == null || "".equals(codeString))
233            return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.NULL, code);
234        if ("maximum".equals(codeString))
235          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.MAXIMUM, code);
236        if ("minimum".equals(codeString))
237          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.MINIMUM, code);
238        if ("required".equals(codeString))
239          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.REQUIRED, code);
240        if ("extensible".equals(codeString))
241          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.EXTENSIBLE, code);
242        if ("candidate".equals(codeString))
243          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.CANDIDATE, code);
244        if ("current".equals(codeString))
245          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.CURRENT, code);
246        if ("preferred".equals(codeString))
247          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.PREFERRED, code);
248        if ("ui".equals(codeString))
249          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.UI, code);
250        if ("starter".equals(codeString))
251          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.STARTER, code);
252        if ("component".equals(codeString))
253          return new Enumeration<AdditionalBindingPurposeVS>(this, AdditionalBindingPurposeVS.COMPONENT, code);
254        throw new FHIRException("Unknown AdditionalBindingPurposeVS code '"+codeString+"'");
255        }
256    public String toCode(AdditionalBindingPurposeVS code) {
257       if (code == AdditionalBindingPurposeVS.NULL)
258           return null;
259       if (code == AdditionalBindingPurposeVS.MAXIMUM)
260        return "maximum";
261      if (code == AdditionalBindingPurposeVS.MINIMUM)
262        return "minimum";
263      if (code == AdditionalBindingPurposeVS.REQUIRED)
264        return "required";
265      if (code == AdditionalBindingPurposeVS.EXTENSIBLE)
266        return "extensible";
267      if (code == AdditionalBindingPurposeVS.CANDIDATE)
268        return "candidate";
269      if (code == AdditionalBindingPurposeVS.CURRENT)
270        return "current";
271      if (code == AdditionalBindingPurposeVS.PREFERRED)
272        return "preferred";
273      if (code == AdditionalBindingPurposeVS.UI)
274        return "ui";
275      if (code == AdditionalBindingPurposeVS.STARTER)
276        return "starter";
277      if (code == AdditionalBindingPurposeVS.COMPONENT)
278        return "component";
279      return "?";
280   }
281    public String toSystem(AdditionalBindingPurposeVS code) {
282      return code.getSystem();
283      }
284    }
285
286    public enum AggregationMode {
287        /**
288         * The reference is a local reference to a contained resource.
289         */
290        CONTAINED, 
291        /**
292         * The reference to a resource that has to be resolved externally to the resource that includes the reference.
293         */
294        REFERENCED, 
295        /**
296         * When the resource is in a Bundle, the resource the reference points to will be found in the same bundle as the resource that includes the reference.
297         */
298        BUNDLED, 
299        /**
300         * added to help the parsers with the generic types
301         */
302        NULL;
303        public static AggregationMode fromCode(String codeString) throws FHIRException {
304            if (codeString == null || "".equals(codeString))
305                return null;
306        if ("contained".equals(codeString))
307          return CONTAINED;
308        if ("referenced".equals(codeString))
309          return REFERENCED;
310        if ("bundled".equals(codeString))
311          return BUNDLED;
312        if (Configuration.isAcceptInvalidEnums())
313          return null;
314        else
315          throw new FHIRException("Unknown AggregationMode code '"+codeString+"'");
316        }
317        public String toCode() {
318          switch (this) {
319            case CONTAINED: return "contained";
320            case REFERENCED: return "referenced";
321            case BUNDLED: return "bundled";
322            case NULL: return null;
323            default: return "?";
324          }
325        }
326        public String getSystem() {
327          switch (this) {
328            case CONTAINED: return "http://hl7.org/fhir/resource-aggregation-mode";
329            case REFERENCED: return "http://hl7.org/fhir/resource-aggregation-mode";
330            case BUNDLED: return "http://hl7.org/fhir/resource-aggregation-mode";
331            case NULL: return null;
332            default: return "?";
333          }
334        }
335        public String getDefinition() {
336          switch (this) {
337            case CONTAINED: return "The reference is a local reference to a contained resource.";
338            case REFERENCED: return "The reference to a resource that has to be resolved externally to the resource that includes the reference.";
339            case BUNDLED: return "When the resource is in a Bundle, the resource the reference points to will be found in the same bundle as the resource that includes the reference.";
340            case NULL: return null;
341            default: return "?";
342          }
343        }
344        public String getDisplay() {
345          switch (this) {
346            case CONTAINED: return "Contained";
347            case REFERENCED: return "Referenced";
348            case BUNDLED: return "Bundled";
349            case NULL: return null;
350            default: return "?";
351          }
352        }
353    }
354
355  public static class AggregationModeEnumFactory implements EnumFactory<AggregationMode> {
356    public AggregationMode fromCode(String codeString) throws IllegalArgumentException {
357      if (codeString == null || "".equals(codeString))
358            if (codeString == null || "".equals(codeString))
359                return null;
360        if ("contained".equals(codeString))
361          return AggregationMode.CONTAINED;
362        if ("referenced".equals(codeString))
363          return AggregationMode.REFERENCED;
364        if ("bundled".equals(codeString))
365          return AggregationMode.BUNDLED;
366        throw new IllegalArgumentException("Unknown AggregationMode code '"+codeString+"'");
367        }
368        public Enumeration<AggregationMode> fromType(PrimitiveType<?> code) throws FHIRException {
369          if (code == null)
370            return null;
371          if (code.isEmpty())
372            return new Enumeration<AggregationMode>(this, AggregationMode.NULL, code);
373          String codeString = ((PrimitiveType) code).asStringValue();
374          if (codeString == null || "".equals(codeString))
375            return new Enumeration<AggregationMode>(this, AggregationMode.NULL, code);
376        if ("contained".equals(codeString))
377          return new Enumeration<AggregationMode>(this, AggregationMode.CONTAINED, code);
378        if ("referenced".equals(codeString))
379          return new Enumeration<AggregationMode>(this, AggregationMode.REFERENCED, code);
380        if ("bundled".equals(codeString))
381          return new Enumeration<AggregationMode>(this, AggregationMode.BUNDLED, code);
382        throw new FHIRException("Unknown AggregationMode code '"+codeString+"'");
383        }
384    public String toCode(AggregationMode code) {
385       if (code == AggregationMode.NULL)
386           return null;
387       if (code == AggregationMode.CONTAINED)
388        return "contained";
389      if (code == AggregationMode.REFERENCED)
390        return "referenced";
391      if (code == AggregationMode.BUNDLED)
392        return "bundled";
393      return "?";
394   }
395    public String toSystem(AggregationMode code) {
396      return code.getSystem();
397      }
398    }
399
400    public enum ConstraintSeverity {
401        /**
402         * If the constraint is violated, the resource is not conformant.
403         */
404        ERROR, 
405        /**
406         * If the constraint is violated, the resource is conformant, but it is not necessarily following best practice.
407         */
408        WARNING, 
409        /**
410         * added to help the parsers with the generic types
411         */
412        NULL;
413        public static ConstraintSeverity fromCode(String codeString) throws FHIRException {
414            if (codeString == null || "".equals(codeString))
415                return null;
416        if ("error".equals(codeString))
417          return ERROR;
418        if ("warning".equals(codeString))
419          return WARNING;
420        if (Configuration.isAcceptInvalidEnums())
421          return null;
422        else
423          throw new FHIRException("Unknown ConstraintSeverity code '"+codeString+"'");
424        }
425        public String toCode() {
426          switch (this) {
427            case ERROR: return "error";
428            case WARNING: return "warning";
429            case NULL: return null;
430            default: return "?";
431          }
432        }
433        public String getSystem() {
434          switch (this) {
435            case ERROR: return "http://hl7.org/fhir/constraint-severity";
436            case WARNING: return "http://hl7.org/fhir/constraint-severity";
437            case NULL: return null;
438            default: return "?";
439          }
440        }
441        public String getDefinition() {
442          switch (this) {
443            case ERROR: return "If the constraint is violated, the resource is not conformant.";
444            case WARNING: return "If the constraint is violated, the resource is conformant, but it is not necessarily following best practice.";
445            case NULL: return null;
446            default: return "?";
447          }
448        }
449        public String getDisplay() {
450          switch (this) {
451            case ERROR: return "Error";
452            case WARNING: return "Warning";
453            case NULL: return null;
454            default: return "?";
455          }
456        }
457    }
458
459  public static class ConstraintSeverityEnumFactory implements EnumFactory<ConstraintSeverity> {
460    public ConstraintSeverity fromCode(String codeString) throws IllegalArgumentException {
461      if (codeString == null || "".equals(codeString))
462            if (codeString == null || "".equals(codeString))
463                return null;
464        if ("error".equals(codeString))
465          return ConstraintSeverity.ERROR;
466        if ("warning".equals(codeString))
467          return ConstraintSeverity.WARNING;
468        throw new IllegalArgumentException("Unknown ConstraintSeverity code '"+codeString+"'");
469        }
470        public Enumeration<ConstraintSeverity> fromType(PrimitiveType<?> code) throws FHIRException {
471          if (code == null)
472            return null;
473          if (code.isEmpty())
474            return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.NULL, code);
475          String codeString = ((PrimitiveType) code).asStringValue();
476          if (codeString == null || "".equals(codeString))
477            return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.NULL, code);
478        if ("error".equals(codeString))
479          return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.ERROR, code);
480        if ("warning".equals(codeString))
481          return new Enumeration<ConstraintSeverity>(this, ConstraintSeverity.WARNING, code);
482        throw new FHIRException("Unknown ConstraintSeverity code '"+codeString+"'");
483        }
484    public String toCode(ConstraintSeverity code) {
485       if (code == ConstraintSeverity.NULL)
486           return null;
487       if (code == ConstraintSeverity.ERROR)
488        return "error";
489      if (code == ConstraintSeverity.WARNING)
490        return "warning";
491      return "?";
492   }
493    public String toSystem(ConstraintSeverity code) {
494      return code.getSystem();
495      }
496    }
497
498    public enum DiscriminatorType {
499        /**
500         * The slices have different values in the nominated element, as determined by the applicable fixed value, pattern, or required ValueSet binding.
501         */
502        VALUE, 
503        /**
504         * The slices are differentiated by the presence or absence of the nominated element. There SHALL be no more than two slices. The slices are differentiated by the fact that one must have a max of 0 and the other must have a min of 1 (or more).  The order in which the slices are declared doesn't matter.
505         */
506        EXISTS, 
507        /**
508         * The slices have different values in the nominated element, as determined by the applicable fixed value, pattern, or required ValueSet binding. This has the same meaning as 'value' and is deprecated.
509         */
510        PATTERN, 
511        /**
512         * The slices are differentiated by type of the nominated element.
513         */
514        TYPE, 
515        /**
516         * The slices are differentiated by conformance of the nominated element to a specified profile. Note that if the path specifies .resolve() then the profile is the target profile on the reference. In this case, validation by the possible profiles is required to differentiate the slices.
517         */
518        PROFILE, 
519        /**
520         * The slices are differentiated by their index. This is only possible if all but the last slice have min=max cardinality, and the (optional) last slice contains other undifferentiated elements.
521         */
522        POSITION, 
523        /**
524         * added to help the parsers with the generic types
525         */
526        NULL;
527        public static DiscriminatorType fromCode(String codeString) throws FHIRException {
528            if (codeString == null || "".equals(codeString))
529                return null;
530        if ("value".equals(codeString))
531          return VALUE;
532        if ("exists".equals(codeString))
533          return EXISTS;
534        if ("pattern".equals(codeString))
535          return PATTERN;
536        if ("type".equals(codeString))
537          return TYPE;
538        if ("profile".equals(codeString))
539          return PROFILE;
540        if ("position".equals(codeString))
541          return POSITION;
542        if (Configuration.isAcceptInvalidEnums())
543          return null;
544        else
545          throw new FHIRException("Unknown DiscriminatorType code '"+codeString+"'");
546        }
547        public String toCode() {
548          switch (this) {
549            case VALUE: return "value";
550            case EXISTS: return "exists";
551            case PATTERN: return "pattern";
552            case TYPE: return "type";
553            case PROFILE: return "profile";
554            case POSITION: return "position";
555            case NULL: return null;
556            default: return "?";
557          }
558        }
559        public String getSystem() {
560          switch (this) {
561            case VALUE: return "http://hl7.org/fhir/discriminator-type";
562            case EXISTS: return "http://hl7.org/fhir/discriminator-type";
563            case PATTERN: return "http://hl7.org/fhir/discriminator-type";
564            case TYPE: return "http://hl7.org/fhir/discriminator-type";
565            case PROFILE: return "http://hl7.org/fhir/discriminator-type";
566            case POSITION: return "http://hl7.org/fhir/discriminator-type";
567            case NULL: return null;
568            default: return "?";
569          }
570        }
571        public String getDefinition() {
572          switch (this) {
573            case VALUE: return "The slices have different values in the nominated element, as determined by the applicable fixed value, pattern, or required ValueSet binding.";
574            case EXISTS: return "The slices are differentiated by the presence or absence of the nominated element. There SHALL be no more than two slices. The slices are differentiated by the fact that one must have a max of 0 and the other must have a min of 1 (or more).  The order in which the slices are declared doesn't matter.";
575            case PATTERN: return "The slices have different values in the nominated element, as determined by the applicable fixed value, pattern, or required ValueSet binding. This has the same meaning as 'value' and is deprecated.";
576            case TYPE: return "The slices are differentiated by type of the nominated element.";
577            case PROFILE: return "The slices are differentiated by conformance of the nominated element to a specified profile. Note that if the path specifies .resolve() then the profile is the target profile on the reference. In this case, validation by the possible profiles is required to differentiate the slices.";
578            case POSITION: return "The slices are differentiated by their index. This is only possible if all but the last slice have min=max cardinality, and the (optional) last slice contains other undifferentiated elements.";
579            case NULL: return null;
580            default: return "?";
581          }
582        }
583        public String getDisplay() {
584          switch (this) {
585            case VALUE: return "Value";
586            case EXISTS: return "Exists";
587            case PATTERN: return "Pattern";
588            case TYPE: return "Type";
589            case PROFILE: return "Profile";
590            case POSITION: return "Position";
591            case NULL: return null;
592            default: return "?";
593          }
594        }
595    }
596
597  public static class DiscriminatorTypeEnumFactory implements EnumFactory<DiscriminatorType> {
598    public DiscriminatorType fromCode(String codeString) throws IllegalArgumentException {
599      if (codeString == null || "".equals(codeString))
600            if (codeString == null || "".equals(codeString))
601                return null;
602        if ("value".equals(codeString))
603          return DiscriminatorType.VALUE;
604        if ("exists".equals(codeString))
605          return DiscriminatorType.EXISTS;
606        if ("pattern".equals(codeString))
607          return DiscriminatorType.PATTERN;
608        if ("type".equals(codeString))
609          return DiscriminatorType.TYPE;
610        if ("profile".equals(codeString))
611          return DiscriminatorType.PROFILE;
612        if ("position".equals(codeString))
613          return DiscriminatorType.POSITION;
614        throw new IllegalArgumentException("Unknown DiscriminatorType code '"+codeString+"'");
615        }
616        public Enumeration<DiscriminatorType> fromType(PrimitiveType<?> code) throws FHIRException {
617          if (code == null)
618            return null;
619          if (code.isEmpty())
620            return new Enumeration<DiscriminatorType>(this, DiscriminatorType.NULL, code);
621          String codeString = ((PrimitiveType) code).asStringValue();
622          if (codeString == null || "".equals(codeString))
623            return new Enumeration<DiscriminatorType>(this, DiscriminatorType.NULL, code);
624        if ("value".equals(codeString))
625          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.VALUE, code);
626        if ("exists".equals(codeString))
627          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.EXISTS, code);
628        if ("pattern".equals(codeString))
629          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.PATTERN, code);
630        if ("type".equals(codeString))
631          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.TYPE, code);
632        if ("profile".equals(codeString))
633          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.PROFILE, code);
634        if ("position".equals(codeString))
635          return new Enumeration<DiscriminatorType>(this, DiscriminatorType.POSITION, code);
636        throw new FHIRException("Unknown DiscriminatorType code '"+codeString+"'");
637        }
638    public String toCode(DiscriminatorType code) {
639       if (code == DiscriminatorType.NULL)
640           return null;
641       if (code == DiscriminatorType.VALUE)
642        return "value";
643      if (code == DiscriminatorType.EXISTS)
644        return "exists";
645      if (code == DiscriminatorType.PATTERN)
646        return "pattern";
647      if (code == DiscriminatorType.TYPE)
648        return "type";
649      if (code == DiscriminatorType.PROFILE)
650        return "profile";
651      if (code == DiscriminatorType.POSITION)
652        return "position";
653      return "?";
654   }
655    public String toSystem(DiscriminatorType code) {
656      return code.getSystem();
657      }
658    }
659
660    public enum PropertyRepresentation {
661        /**
662         * In XML, this property is represented as an attribute not an element.
663         */
664        XMLATTR, 
665        /**
666         * This element is represented using the XML text attribute (primitives only).
667         */
668        XMLTEXT, 
669        /**
670         * The type of this element is indicated using xsi:type.
671         */
672        TYPEATTR, 
673        /**
674         * Use CDA narrative instead of XHTML.
675         */
676        CDATEXT, 
677        /**
678         * The property is represented using XHTML.
679         */
680        XHTML, 
681        /**
682         * added to help the parsers with the generic types
683         */
684        NULL;
685        public static PropertyRepresentation fromCode(String codeString) throws FHIRException {
686            if (codeString == null || "".equals(codeString))
687                return null;
688        if ("xmlAttr".equals(codeString))
689          return XMLATTR;
690        if ("xmlText".equals(codeString))
691          return XMLTEXT;
692        if ("typeAttr".equals(codeString))
693          return TYPEATTR;
694        if ("cdaText".equals(codeString))
695          return CDATEXT;
696        if ("xhtml".equals(codeString))
697          return XHTML;
698        if (Configuration.isAcceptInvalidEnums())
699          return null;
700        else
701          throw new FHIRException("Unknown PropertyRepresentation code '"+codeString+"'");
702        }
703        public String toCode() {
704          switch (this) {
705            case XMLATTR: return "xmlAttr";
706            case XMLTEXT: return "xmlText";
707            case TYPEATTR: return "typeAttr";
708            case CDATEXT: return "cdaText";
709            case XHTML: return "xhtml";
710            case NULL: return null;
711            default: return "?";
712          }
713        }
714        public String getSystem() {
715          switch (this) {
716            case XMLATTR: return "http://hl7.org/fhir/property-representation";
717            case XMLTEXT: return "http://hl7.org/fhir/property-representation";
718            case TYPEATTR: return "http://hl7.org/fhir/property-representation";
719            case CDATEXT: return "http://hl7.org/fhir/property-representation";
720            case XHTML: return "http://hl7.org/fhir/property-representation";
721            case NULL: return null;
722            default: return "?";
723          }
724        }
725        public String getDefinition() {
726          switch (this) {
727            case XMLATTR: return "In XML, this property is represented as an attribute not an element.";
728            case XMLTEXT: return "This element is represented using the XML text attribute (primitives only).";
729            case TYPEATTR: return "The type of this element is indicated using xsi:type.";
730            case CDATEXT: return "Use CDA narrative instead of XHTML.";
731            case XHTML: return "The property is represented using XHTML.";
732            case NULL: return null;
733            default: return "?";
734          }
735        }
736        public String getDisplay() {
737          switch (this) {
738            case XMLATTR: return "XML Attribute";
739            case XMLTEXT: return "XML Text";
740            case TYPEATTR: return "Type Attribute";
741            case CDATEXT: return "CDA Text Format";
742            case XHTML: return "XHTML";
743            case NULL: return null;
744            default: return "?";
745          }
746        }
747    }
748
749  public static class PropertyRepresentationEnumFactory implements EnumFactory<PropertyRepresentation> {
750    public PropertyRepresentation fromCode(String codeString) throws IllegalArgumentException {
751      if (codeString == null || "".equals(codeString))
752            if (codeString == null || "".equals(codeString))
753                return null;
754        if ("xmlAttr".equals(codeString))
755          return PropertyRepresentation.XMLATTR;
756        if ("xmlText".equals(codeString))
757          return PropertyRepresentation.XMLTEXT;
758        if ("typeAttr".equals(codeString))
759          return PropertyRepresentation.TYPEATTR;
760        if ("cdaText".equals(codeString))
761          return PropertyRepresentation.CDATEXT;
762        if ("xhtml".equals(codeString))
763          return PropertyRepresentation.XHTML;
764        throw new IllegalArgumentException("Unknown PropertyRepresentation code '"+codeString+"'");
765        }
766        public Enumeration<PropertyRepresentation> fromType(PrimitiveType<?> code) throws FHIRException {
767          if (code == null)
768            return null;
769          if (code.isEmpty())
770            return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.NULL, code);
771          String codeString = ((PrimitiveType) code).asStringValue();
772          if (codeString == null || "".equals(codeString))
773            return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.NULL, code);
774        if ("xmlAttr".equals(codeString))
775          return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XMLATTR, code);
776        if ("xmlText".equals(codeString))
777          return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XMLTEXT, code);
778        if ("typeAttr".equals(codeString))
779          return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.TYPEATTR, code);
780        if ("cdaText".equals(codeString))
781          return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.CDATEXT, code);
782        if ("xhtml".equals(codeString))
783          return new Enumeration<PropertyRepresentation>(this, PropertyRepresentation.XHTML, code);
784        throw new FHIRException("Unknown PropertyRepresentation code '"+codeString+"'");
785        }
786    public String toCode(PropertyRepresentation code) {
787       if (code == PropertyRepresentation.NULL)
788           return null;
789       if (code == PropertyRepresentation.XMLATTR)
790        return "xmlAttr";
791      if (code == PropertyRepresentation.XMLTEXT)
792        return "xmlText";
793      if (code == PropertyRepresentation.TYPEATTR)
794        return "typeAttr";
795      if (code == PropertyRepresentation.CDATEXT)
796        return "cdaText";
797      if (code == PropertyRepresentation.XHTML)
798        return "xhtml";
799      return "?";
800   }
801    public String toSystem(PropertyRepresentation code) {
802      return code.getSystem();
803      }
804    }
805
806    public enum ReferenceVersionRules {
807        /**
808         * The reference may be either version independent or version specific.
809         */
810        EITHER, 
811        /**
812         * The reference must be version independent.
813         */
814        INDEPENDENT, 
815        /**
816         * The reference must be version specific.
817         */
818        SPECIFIC, 
819        /**
820         * added to help the parsers with the generic types
821         */
822        NULL;
823        public static ReferenceVersionRules fromCode(String codeString) throws FHIRException {
824            if (codeString == null || "".equals(codeString))
825                return null;
826        if ("either".equals(codeString))
827          return EITHER;
828        if ("independent".equals(codeString))
829          return INDEPENDENT;
830        if ("specific".equals(codeString))
831          return SPECIFIC;
832        if (Configuration.isAcceptInvalidEnums())
833          return null;
834        else
835          throw new FHIRException("Unknown ReferenceVersionRules code '"+codeString+"'");
836        }
837        public String toCode() {
838          switch (this) {
839            case EITHER: return "either";
840            case INDEPENDENT: return "independent";
841            case SPECIFIC: return "specific";
842            case NULL: return null;
843            default: return "?";
844          }
845        }
846        public String getSystem() {
847          switch (this) {
848            case EITHER: return "http://hl7.org/fhir/reference-version-rules";
849            case INDEPENDENT: return "http://hl7.org/fhir/reference-version-rules";
850            case SPECIFIC: return "http://hl7.org/fhir/reference-version-rules";
851            case NULL: return null;
852            default: return "?";
853          }
854        }
855        public String getDefinition() {
856          switch (this) {
857            case EITHER: return "The reference may be either version independent or version specific.";
858            case INDEPENDENT: return "The reference must be version independent.";
859            case SPECIFIC: return "The reference must be version specific.";
860            case NULL: return null;
861            default: return "?";
862          }
863        }
864        public String getDisplay() {
865          switch (this) {
866            case EITHER: return "Either Specific or independent";
867            case INDEPENDENT: return "Version independent";
868            case SPECIFIC: return "Version Specific";
869            case NULL: return null;
870            default: return "?";
871          }
872        }
873    }
874
875  public static class ReferenceVersionRulesEnumFactory implements EnumFactory<ReferenceVersionRules> {
876    public ReferenceVersionRules fromCode(String codeString) throws IllegalArgumentException {
877      if (codeString == null || "".equals(codeString))
878            if (codeString == null || "".equals(codeString))
879                return null;
880        if ("either".equals(codeString))
881          return ReferenceVersionRules.EITHER;
882        if ("independent".equals(codeString))
883          return ReferenceVersionRules.INDEPENDENT;
884        if ("specific".equals(codeString))
885          return ReferenceVersionRules.SPECIFIC;
886        throw new IllegalArgumentException("Unknown ReferenceVersionRules code '"+codeString+"'");
887        }
888        public Enumeration<ReferenceVersionRules> fromType(PrimitiveType<?> code) throws FHIRException {
889          if (code == null)
890            return null;
891          if (code.isEmpty())
892            return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.NULL, code);
893          String codeString = ((PrimitiveType) code).asStringValue();
894          if (codeString == null || "".equals(codeString))
895            return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.NULL, code);
896        if ("either".equals(codeString))
897          return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.EITHER, code);
898        if ("independent".equals(codeString))
899          return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.INDEPENDENT, code);
900        if ("specific".equals(codeString))
901          return new Enumeration<ReferenceVersionRules>(this, ReferenceVersionRules.SPECIFIC, code);
902        throw new FHIRException("Unknown ReferenceVersionRules code '"+codeString+"'");
903        }
904    public String toCode(ReferenceVersionRules code) {
905       if (code == ReferenceVersionRules.NULL)
906           return null;
907       if (code == ReferenceVersionRules.EITHER)
908        return "either";
909      if (code == ReferenceVersionRules.INDEPENDENT)
910        return "independent";
911      if (code == ReferenceVersionRules.SPECIFIC)
912        return "specific";
913      return "?";
914   }
915    public String toSystem(ReferenceVersionRules code) {
916      return code.getSystem();
917      }
918    }
919
920    public enum SlicingRules {
921        /**
922         * No additional content is allowed other than that described by the slices in this profile.
923         */
924        CLOSED, 
925        /**
926         * Additional content is allowed anywhere in the list.
927         */
928        OPEN, 
929        /**
930         * Additional content is allowed, but only at the end of the list. Note that using this requires that the slices be ordered, which makes it hard to share uses. This should only be done where absolutely required.
931         */
932        OPENATEND, 
933        /**
934         * added to help the parsers with the generic types
935         */
936        NULL;
937        public static SlicingRules fromCode(String codeString) throws FHIRException {
938            if (codeString == null || "".equals(codeString))
939                return null;
940        if ("closed".equals(codeString))
941          return CLOSED;
942        if ("open".equals(codeString))
943          return OPEN;
944        if ("openAtEnd".equals(codeString))
945          return OPENATEND;
946        if (Configuration.isAcceptInvalidEnums())
947          return null;
948        else
949          throw new FHIRException("Unknown SlicingRules code '"+codeString+"'");
950        }
951        public String toCode() {
952          switch (this) {
953            case CLOSED: return "closed";
954            case OPEN: return "open";
955            case OPENATEND: return "openAtEnd";
956            case NULL: return null;
957            default: return "?";
958          }
959        }
960        public String getSystem() {
961          switch (this) {
962            case CLOSED: return "http://hl7.org/fhir/resource-slicing-rules";
963            case OPEN: return "http://hl7.org/fhir/resource-slicing-rules";
964            case OPENATEND: return "http://hl7.org/fhir/resource-slicing-rules";
965            case NULL: return null;
966            default: return "?";
967          }
968        }
969        public String getDefinition() {
970          switch (this) {
971            case CLOSED: return "No additional content is allowed other than that described by the slices in this profile.";
972            case OPEN: return "Additional content is allowed anywhere in the list.";
973            case OPENATEND: return "Additional content is allowed, but only at the end of the list. Note that using this requires that the slices be ordered, which makes it hard to share uses. This should only be done where absolutely required.";
974            case NULL: return null;
975            default: return "?";
976          }
977        }
978        public String getDisplay() {
979          switch (this) {
980            case CLOSED: return "Closed";
981            case OPEN: return "Open";
982            case OPENATEND: return "Open at End";
983            case NULL: return null;
984            default: return "?";
985          }
986        }
987    }
988
989  public static class SlicingRulesEnumFactory implements EnumFactory<SlicingRules> {
990    public SlicingRules fromCode(String codeString) throws IllegalArgumentException {
991      if (codeString == null || "".equals(codeString))
992            if (codeString == null || "".equals(codeString))
993                return null;
994        if ("closed".equals(codeString))
995          return SlicingRules.CLOSED;
996        if ("open".equals(codeString))
997          return SlicingRules.OPEN;
998        if ("openAtEnd".equals(codeString))
999          return SlicingRules.OPENATEND;
1000        throw new IllegalArgumentException("Unknown SlicingRules code '"+codeString+"'");
1001        }
1002        public Enumeration<SlicingRules> fromType(PrimitiveType<?> code) throws FHIRException {
1003          if (code == null)
1004            return null;
1005          if (code.isEmpty())
1006            return new Enumeration<SlicingRules>(this, SlicingRules.NULL, code);
1007          String codeString = ((PrimitiveType) code).asStringValue();
1008          if (codeString == null || "".equals(codeString))
1009            return new Enumeration<SlicingRules>(this, SlicingRules.NULL, code);
1010        if ("closed".equals(codeString))
1011          return new Enumeration<SlicingRules>(this, SlicingRules.CLOSED, code);
1012        if ("open".equals(codeString))
1013          return new Enumeration<SlicingRules>(this, SlicingRules.OPEN, code);
1014        if ("openAtEnd".equals(codeString))
1015          return new Enumeration<SlicingRules>(this, SlicingRules.OPENATEND, code);
1016        throw new FHIRException("Unknown SlicingRules code '"+codeString+"'");
1017        }
1018    public String toCode(SlicingRules code) {
1019       if (code == SlicingRules.NULL)
1020           return null;
1021       if (code == SlicingRules.CLOSED)
1022        return "closed";
1023      if (code == SlicingRules.OPEN)
1024        return "open";
1025      if (code == SlicingRules.OPENATEND)
1026        return "openAtEnd";
1027      return "?";
1028   }
1029    public String toSystem(SlicingRules code) {
1030      return code.getSystem();
1031      }
1032    }
1033
1034    @Block()
1035    public static class ElementDefinitionSlicingComponent extends Element implements IBaseDatatypeElement {
1036        /**
1037         * Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.
1038         */
1039        @Child(name = "discriminator", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1040        @Description(shortDefinition="Element values that are used to distinguish the slices", formalDefinition="Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices." )
1041        protected List<ElementDefinitionSlicingDiscriminatorComponent> discriminator;
1042
1043        /**
1044         * A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.
1045         */
1046        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1047        @Description(shortDefinition="Text description of how slicing works (or not)", formalDefinition="A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated." )
1048        protected StringType description;
1049
1050        /**
1051         * If the matching elements have to occur in the same order as defined in the profile.
1052         */
1053        @Child(name = "ordered", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1054        @Description(shortDefinition="If elements must be in same order as slices", formalDefinition="If the matching elements have to occur in the same order as defined in the profile." )
1055        protected BooleanType ordered;
1056
1057        /**
1058         * Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.
1059         */
1060        @Child(name = "rules", type = {CodeType.class}, order=4, min=1, max=1, modifier=false, summary=true)
1061        @Description(shortDefinition="closed | open | openAtEnd", formalDefinition="Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end." )
1062        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-slicing-rules")
1063        protected Enumeration<SlicingRules> rules;
1064
1065        private static final long serialVersionUID = -311635839L;
1066
1067    /**
1068     * Constructor
1069     */
1070      public ElementDefinitionSlicingComponent() {
1071        super();
1072      }
1073
1074    /**
1075     * Constructor
1076     */
1077      public ElementDefinitionSlicingComponent(SlicingRules rules) {
1078        super();
1079        this.setRules(rules);
1080      }
1081
1082        /**
1083         * @return {@link #discriminator} (Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.)
1084         */
1085        public List<ElementDefinitionSlicingDiscriminatorComponent> getDiscriminator() { 
1086          if (this.discriminator == null)
1087            this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>();
1088          return this.discriminator;
1089        }
1090
1091        /**
1092         * @return Returns a reference to <code>this</code> for easy method chaining
1093         */
1094        public ElementDefinitionSlicingComponent setDiscriminator(List<ElementDefinitionSlicingDiscriminatorComponent> theDiscriminator) { 
1095          this.discriminator = theDiscriminator;
1096          return this;
1097        }
1098
1099        public boolean hasDiscriminator() { 
1100          if (this.discriminator == null)
1101            return false;
1102          for (ElementDefinitionSlicingDiscriminatorComponent item : this.discriminator)
1103            if (!item.isEmpty())
1104              return true;
1105          return false;
1106        }
1107
1108        public ElementDefinitionSlicingDiscriminatorComponent addDiscriminator() { //3
1109          ElementDefinitionSlicingDiscriminatorComponent t = new ElementDefinitionSlicingDiscriminatorComponent();
1110          if (this.discriminator == null)
1111            this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>();
1112          this.discriminator.add(t);
1113          return t;
1114        }
1115
1116        public ElementDefinitionSlicingComponent addDiscriminator(ElementDefinitionSlicingDiscriminatorComponent t) { //3
1117          if (t == null)
1118            return this;
1119          if (this.discriminator == null)
1120            this.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>();
1121          this.discriminator.add(t);
1122          return this;
1123        }
1124
1125        /**
1126         * @return The first repetition of repeating field {@link #discriminator}, creating it if it does not already exist {3}
1127         */
1128        public ElementDefinitionSlicingDiscriminatorComponent getDiscriminatorFirstRep() { 
1129          if (getDiscriminator().isEmpty()) {
1130            addDiscriminator();
1131          }
1132          return getDiscriminator().get(0);
1133        }
1134
1135        /**
1136         * @return {@link #description} (A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1137         */
1138        public StringType getDescriptionElement() { 
1139          if (this.description == null)
1140            if (Configuration.errorOnAutoCreate())
1141              throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.description");
1142            else if (Configuration.doAutoCreate())
1143              this.description = new StringType(); // bb
1144          return this.description;
1145        }
1146
1147        public boolean hasDescriptionElement() { 
1148          return this.description != null && !this.description.isEmpty();
1149        }
1150
1151        public boolean hasDescription() { 
1152          return this.description != null && !this.description.isEmpty();
1153        }
1154
1155        /**
1156         * @param value {@link #description} (A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1157         */
1158        public ElementDefinitionSlicingComponent setDescriptionElement(StringType value) { 
1159          this.description = value;
1160          return this;
1161        }
1162
1163        /**
1164         * @return A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.
1165         */
1166        public String getDescription() { 
1167          return this.description == null ? null : this.description.getValue();
1168        }
1169
1170        /**
1171         * @param value A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.
1172         */
1173        public ElementDefinitionSlicingComponent setDescription(String value) { 
1174          if (Utilities.noString(value))
1175            this.description = null;
1176          else {
1177            if (this.description == null)
1178              this.description = new StringType();
1179            this.description.setValue(value);
1180          }
1181          return this;
1182        }
1183
1184        /**
1185         * @return {@link #ordered} (If the matching elements have to occur in the same order as defined in the profile.). This is the underlying object with id, value and extensions. The accessor "getOrdered" gives direct access to the value
1186         */
1187        public BooleanType getOrderedElement() { 
1188          if (this.ordered == null)
1189            if (Configuration.errorOnAutoCreate())
1190              throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.ordered");
1191            else if (Configuration.doAutoCreate())
1192              this.ordered = new BooleanType(); // bb
1193          return this.ordered;
1194        }
1195
1196        public boolean hasOrderedElement() { 
1197          return this.ordered != null && !this.ordered.isEmpty();
1198        }
1199
1200        public boolean hasOrdered() { 
1201          return this.ordered != null && !this.ordered.isEmpty();
1202        }
1203
1204        /**
1205         * @param value {@link #ordered} (If the matching elements have to occur in the same order as defined in the profile.). This is the underlying object with id, value and extensions. The accessor "getOrdered" gives direct access to the value
1206         */
1207        public ElementDefinitionSlicingComponent setOrderedElement(BooleanType value) { 
1208          this.ordered = value;
1209          return this;
1210        }
1211
1212        /**
1213         * @return If the matching elements have to occur in the same order as defined in the profile.
1214         */
1215        public boolean getOrdered() { 
1216          return this.ordered == null || this.ordered.isEmpty() ? false : this.ordered.getValue();
1217        }
1218
1219        /**
1220         * @param value If the matching elements have to occur in the same order as defined in the profile.
1221         */
1222        public ElementDefinitionSlicingComponent setOrdered(boolean value) { 
1223            if (this.ordered == null)
1224              this.ordered = new BooleanType();
1225            this.ordered.setValue(value);
1226          return this;
1227        }
1228
1229        /**
1230         * @return {@link #rules} (Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.). This is the underlying object with id, value and extensions. The accessor "getRules" gives direct access to the value
1231         */
1232        public Enumeration<SlicingRules> getRulesElement() { 
1233          if (this.rules == null)
1234            if (Configuration.errorOnAutoCreate())
1235              throw new Error("Attempt to auto-create ElementDefinitionSlicingComponent.rules");
1236            else if (Configuration.doAutoCreate())
1237              this.rules = new Enumeration<SlicingRules>(new SlicingRulesEnumFactory()); // bb
1238          return this.rules;
1239        }
1240
1241        public boolean hasRulesElement() { 
1242          return this.rules != null && !this.rules.isEmpty();
1243        }
1244
1245        public boolean hasRules() { 
1246          return this.rules != null && !this.rules.isEmpty();
1247        }
1248
1249        /**
1250         * @param value {@link #rules} (Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.). This is the underlying object with id, value and extensions. The accessor "getRules" gives direct access to the value
1251         */
1252        public ElementDefinitionSlicingComponent setRulesElement(Enumeration<SlicingRules> value) { 
1253          this.rules = value;
1254          return this;
1255        }
1256
1257        /**
1258         * @return Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.
1259         */
1260        public SlicingRules getRules() { 
1261          return this.rules == null ? null : this.rules.getValue();
1262        }
1263
1264        /**
1265         * @param value Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.
1266         */
1267        public ElementDefinitionSlicingComponent setRules(SlicingRules value) { 
1268            if (this.rules == null)
1269              this.rules = new Enumeration<SlicingRules>(new SlicingRulesEnumFactory());
1270            this.rules.setValue(value);
1271          return this;
1272        }
1273
1274        protected void listChildren(List<Property> children) {
1275          super.listChildren(children);
1276          children.add(new Property("discriminator", "", "Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.", 0, java.lang.Integer.MAX_VALUE, discriminator));
1277          children.add(new Property("description", "string", "A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.", 0, 1, description));
1278          children.add(new Property("ordered", "boolean", "If the matching elements have to occur in the same order as defined in the profile.", 0, 1, ordered));
1279          children.add(new Property("rules", "code", "Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.", 0, 1, rules));
1280        }
1281
1282        @Override
1283        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1284          switch (_hash) {
1285          case -1888270692: /*discriminator*/  return new Property("discriminator", "", "Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.", 0, java.lang.Integer.MAX_VALUE, discriminator);
1286          case -1724546052: /*description*/  return new Property("description", "string", "A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.", 0, 1, description);
1287          case -1207109523: /*ordered*/  return new Property("ordered", "boolean", "If the matching elements have to occur in the same order as defined in the profile.", 0, 1, ordered);
1288          case 108873975: /*rules*/  return new Property("rules", "code", "Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.", 0, 1, rules);
1289          default: return super.getNamedProperty(_hash, _name, _checkValid);
1290          }
1291
1292        }
1293
1294      @Override
1295      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1296        switch (hash) {
1297        case -1888270692: /*discriminator*/ return this.discriminator == null ? new Base[0] : this.discriminator.toArray(new Base[this.discriminator.size()]); // ElementDefinitionSlicingDiscriminatorComponent
1298        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
1299        case -1207109523: /*ordered*/ return this.ordered == null ? new Base[0] : new Base[] {this.ordered}; // BooleanType
1300        case 108873975: /*rules*/ return this.rules == null ? new Base[0] : new Base[] {this.rules}; // Enumeration<SlicingRules>
1301        default: return super.getProperty(hash, name, checkValid);
1302        }
1303
1304      }
1305
1306      @Override
1307      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1308        switch (hash) {
1309        case -1888270692: // discriminator
1310          this.getDiscriminator().add((ElementDefinitionSlicingDiscriminatorComponent) value); // ElementDefinitionSlicingDiscriminatorComponent
1311          return value;
1312        case -1724546052: // description
1313          this.description = TypeConvertor.castToString(value); // StringType
1314          return value;
1315        case -1207109523: // ordered
1316          this.ordered = TypeConvertor.castToBoolean(value); // BooleanType
1317          return value;
1318        case 108873975: // rules
1319          value = new SlicingRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
1320          this.rules = (Enumeration) value; // Enumeration<SlicingRules>
1321          return value;
1322        default: return super.setProperty(hash, name, value);
1323        }
1324
1325      }
1326
1327      @Override
1328      public Base setProperty(String name, Base value) throws FHIRException {
1329        if (name.equals("discriminator")) {
1330          this.getDiscriminator().add((ElementDefinitionSlicingDiscriminatorComponent) value);
1331        } else if (name.equals("description")) {
1332          this.description = TypeConvertor.castToString(value); // StringType
1333        } else if (name.equals("ordered")) {
1334          this.ordered = TypeConvertor.castToBoolean(value); // BooleanType
1335        } else if (name.equals("rules")) {
1336          value = new SlicingRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
1337          this.rules = (Enumeration) value; // Enumeration<SlicingRules>
1338        } else
1339          return super.setProperty(name, value);
1340        return value;
1341      }
1342
1343  @Override
1344  public void removeChild(String name, Base value) throws FHIRException {
1345        if (name.equals("discriminator")) {
1346          this.getDiscriminator().remove((ElementDefinitionSlicingDiscriminatorComponent) value);
1347        } else if (name.equals("description")) {
1348          this.description = null;
1349        } else if (name.equals("ordered")) {
1350          this.ordered = null;
1351        } else if (name.equals("rules")) {
1352          value = new SlicingRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
1353          this.rules = (Enumeration) value; // Enumeration<SlicingRules>
1354        } else
1355          super.removeChild(name, value);
1356        
1357      }
1358
1359      @Override
1360      public Base makeProperty(int hash, String name) throws FHIRException {
1361        switch (hash) {
1362        case -1888270692:  return addDiscriminator(); 
1363        case -1724546052:  return getDescriptionElement();
1364        case -1207109523:  return getOrderedElement();
1365        case 108873975:  return getRulesElement();
1366        default: return super.makeProperty(hash, name);
1367        }
1368
1369      }
1370
1371      @Override
1372      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1373        switch (hash) {
1374        case -1888270692: /*discriminator*/ return new String[] {};
1375        case -1724546052: /*description*/ return new String[] {"string"};
1376        case -1207109523: /*ordered*/ return new String[] {"boolean"};
1377        case 108873975: /*rules*/ return new String[] {"code"};
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("discriminator")) {
1386          return addDiscriminator();
1387        }
1388        else if (name.equals("description")) {
1389          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.slicing.description");
1390        }
1391        else if (name.equals("ordered")) {
1392          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.slicing.ordered");
1393        }
1394        else if (name.equals("rules")) {
1395          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.slicing.rules");
1396        }
1397        else
1398          return super.addChild(name);
1399      }
1400
1401      public ElementDefinitionSlicingComponent copy() {
1402        ElementDefinitionSlicingComponent dst = new ElementDefinitionSlicingComponent();
1403        copyValues(dst);
1404        return dst;
1405      }
1406
1407      public void copyValues(ElementDefinitionSlicingComponent dst) {
1408        super.copyValues(dst);
1409        if (discriminator != null) {
1410          dst.discriminator = new ArrayList<ElementDefinitionSlicingDiscriminatorComponent>();
1411          for (ElementDefinitionSlicingDiscriminatorComponent i : discriminator)
1412            dst.discriminator.add(i.copy());
1413        };
1414        dst.description = description == null ? null : description.copy();
1415        dst.ordered = ordered == null ? null : ordered.copy();
1416        dst.rules = rules == null ? null : rules.copy();
1417      }
1418
1419      @Override
1420      public boolean equalsDeep(Base other_) {
1421        if (!super.equalsDeep(other_))
1422          return false;
1423        if (!(other_ instanceof ElementDefinitionSlicingComponent))
1424          return false;
1425        ElementDefinitionSlicingComponent o = (ElementDefinitionSlicingComponent) other_;
1426        return compareDeep(discriminator, o.discriminator, true) && compareDeep(description, o.description, true)
1427           && compareDeep(ordered, o.ordered, true) && compareDeep(rules, o.rules, true);
1428      }
1429
1430      @Override
1431      public boolean equalsShallow(Base other_) {
1432        if (!super.equalsShallow(other_))
1433          return false;
1434        if (!(other_ instanceof ElementDefinitionSlicingComponent))
1435          return false;
1436        ElementDefinitionSlicingComponent o = (ElementDefinitionSlicingComponent) other_;
1437        return compareValues(description, o.description, true) && compareValues(ordered, o.ordered, true) && compareValues(rules, o.rules, true)
1438          ;
1439      }
1440
1441      public boolean isEmpty() {
1442        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(discriminator, description
1443          , ordered, rules);
1444      }
1445
1446      public String fhirType() {
1447        return "ElementDefinition.slicing";
1448
1449      }
1450
1451      @Override
1452      public String toString() {
1453        return (ordered == null ? "??" : "true".equals(ordered.asStringValue()) ? "ordered" : "unordered")+"/"+
1454            (rules == null ? "??" : rules.asStringValue())+" "+discriminator.toString();
1455      }
1456    }
1457
1458    @Block()
1459    public static class ElementDefinitionSlicingDiscriminatorComponent extends Element implements IBaseDatatypeElement {
1460        /**
1461         * How the element value is interpreted when discrimination is evaluated.
1462         */
1463        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1464        @Description(shortDefinition="value | exists | type | profile | position", formalDefinition="How the element value is interpreted when discrimination is evaluated." )
1465        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/discriminator-type")
1466        protected Enumeration<DiscriminatorType> type;
1467
1468        /**
1469         * A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.
1470         */
1471        @Child(name = "path", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=true)
1472        @Description(shortDefinition="Path to element value", formalDefinition="A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based." )
1473        protected StringType path;
1474
1475        private static final long serialVersionUID = 1151159293L;
1476
1477    /**
1478     * Constructor
1479     */
1480      public ElementDefinitionSlicingDiscriminatorComponent() {
1481        super();
1482      }
1483
1484    /**
1485     * Constructor
1486     */
1487      public ElementDefinitionSlicingDiscriminatorComponent(DiscriminatorType type, String path) {
1488        super();
1489        this.setType(type);
1490        this.setPath(path);
1491      }
1492
1493        /**
1494         * @return {@link #type} (How the element value is interpreted when discrimination is evaluated.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1495         */
1496        public Enumeration<DiscriminatorType> getTypeElement() { 
1497          if (this.type == null)
1498            if (Configuration.errorOnAutoCreate())
1499              throw new Error("Attempt to auto-create ElementDefinitionSlicingDiscriminatorComponent.type");
1500            else if (Configuration.doAutoCreate())
1501              this.type = new Enumeration<DiscriminatorType>(new DiscriminatorTypeEnumFactory()); // bb
1502          return this.type;
1503        }
1504
1505        public boolean hasTypeElement() { 
1506          return this.type != null && !this.type.isEmpty();
1507        }
1508
1509        public boolean hasType() { 
1510          return this.type != null && !this.type.isEmpty();
1511        }
1512
1513        /**
1514         * @param value {@link #type} (How the element value is interpreted when discrimination is evaluated.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1515         */
1516        public ElementDefinitionSlicingDiscriminatorComponent setTypeElement(Enumeration<DiscriminatorType> value) { 
1517          this.type = value;
1518          return this;
1519        }
1520
1521        /**
1522         * @return How the element value is interpreted when discrimination is evaluated.
1523         */
1524        public DiscriminatorType getType() { 
1525          return this.type == null ? null : this.type.getValue();
1526        }
1527
1528        /**
1529         * @param value How the element value is interpreted when discrimination is evaluated.
1530         */
1531        public ElementDefinitionSlicingDiscriminatorComponent setType(DiscriminatorType value) { 
1532            if (this.type == null)
1533              this.type = new Enumeration<DiscriminatorType>(new DiscriminatorTypeEnumFactory());
1534            this.type.setValue(value);
1535          return this;
1536        }
1537
1538        /**
1539         * @return {@link #path} (A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
1540         */
1541        public StringType getPathElement() { 
1542          if (this.path == null)
1543            if (Configuration.errorOnAutoCreate())
1544              throw new Error("Attempt to auto-create ElementDefinitionSlicingDiscriminatorComponent.path");
1545            else if (Configuration.doAutoCreate())
1546              this.path = new StringType(); // bb
1547          return this.path;
1548        }
1549
1550        public boolean hasPathElement() { 
1551          return this.path != null && !this.path.isEmpty();
1552        }
1553
1554        public boolean hasPath() { 
1555          return this.path != null && !this.path.isEmpty();
1556        }
1557
1558        /**
1559         * @param value {@link #path} (A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
1560         */
1561        public ElementDefinitionSlicingDiscriminatorComponent setPathElement(StringType value) { 
1562          this.path = value;
1563          return this;
1564        }
1565
1566        /**
1567         * @return A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.
1568         */
1569        public String getPath() { 
1570          return this.path == null ? null : this.path.getValue();
1571        }
1572
1573        /**
1574         * @param value A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.
1575         */
1576        public ElementDefinitionSlicingDiscriminatorComponent setPath(String value) { 
1577            if (this.path == null)
1578              this.path = new StringType();
1579            this.path.setValue(value);
1580          return this;
1581        }
1582
1583        protected void listChildren(List<Property> children) {
1584          super.listChildren(children);
1585          children.add(new Property("type", "code", "How the element value is interpreted when discrimination is evaluated.", 0, 1, type));
1586          children.add(new Property("path", "string", "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.", 0, 1, path));
1587        }
1588
1589        @Override
1590        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1591          switch (_hash) {
1592          case 3575610: /*type*/  return new Property("type", "code", "How the element value is interpreted when discrimination is evaluated.", 0, 1, type);
1593          case 3433509: /*path*/  return new Property("path", "string", "A FHIRPath expression, using [the simple subset of FHIRPath](fhirpath.html#simple), that is used to identify the element on which discrimination is based.", 0, 1, path);
1594          default: return super.getNamedProperty(_hash, _name, _checkValid);
1595          }
1596
1597        }
1598
1599      @Override
1600      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1601        switch (hash) {
1602        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<DiscriminatorType>
1603        case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType
1604        default: return super.getProperty(hash, name, checkValid);
1605        }
1606
1607      }
1608
1609      @Override
1610      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1611        switch (hash) {
1612        case 3575610: // type
1613          value = new DiscriminatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
1614          this.type = (Enumeration) value; // Enumeration<DiscriminatorType>
1615          return value;
1616        case 3433509: // path
1617          this.path = TypeConvertor.castToString(value); // StringType
1618          return value;
1619        default: return super.setProperty(hash, name, value);
1620        }
1621
1622      }
1623
1624      @Override
1625      public Base setProperty(String name, Base value) throws FHIRException {
1626        if (name.equals("type")) {
1627          value = new DiscriminatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
1628          this.type = (Enumeration) value; // Enumeration<DiscriminatorType>
1629        } else if (name.equals("path")) {
1630          this.path = TypeConvertor.castToString(value); // StringType
1631        } else
1632          return super.setProperty(name, value);
1633        return value;
1634      }
1635
1636  @Override
1637  public void removeChild(String name, Base value) throws FHIRException {
1638        if (name.equals("type")) {
1639          value = new DiscriminatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
1640          this.type = (Enumeration) value; // Enumeration<DiscriminatorType>
1641        } else if (name.equals("path")) {
1642          this.path = null;
1643        } else
1644          super.removeChild(name, value);
1645        
1646      }
1647
1648      @Override
1649      public Base makeProperty(int hash, String name) throws FHIRException {
1650        switch (hash) {
1651        case 3575610:  return getTypeElement();
1652        case 3433509:  return getPathElement();
1653        default: return super.makeProperty(hash, name);
1654        }
1655
1656      }
1657
1658      @Override
1659      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1660        switch (hash) {
1661        case 3575610: /*type*/ return new String[] {"code"};
1662        case 3433509: /*path*/ return new String[] {"string"};
1663        default: return super.getTypesForProperty(hash, name);
1664        }
1665
1666      }
1667
1668      @Override
1669      public Base addChild(String name) throws FHIRException {
1670        if (name.equals("type")) {
1671          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.slicing.discriminator.type");
1672        }
1673        else if (name.equals("path")) {
1674          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.slicing.discriminator.path");
1675        }
1676        else
1677          return super.addChild(name);
1678      }
1679
1680      public ElementDefinitionSlicingDiscriminatorComponent copy() {
1681        ElementDefinitionSlicingDiscriminatorComponent dst = new ElementDefinitionSlicingDiscriminatorComponent();
1682        copyValues(dst);
1683        return dst;
1684      }
1685
1686      public void copyValues(ElementDefinitionSlicingDiscriminatorComponent dst) {
1687        super.copyValues(dst);
1688        dst.type = type == null ? null : type.copy();
1689        dst.path = path == null ? null : path.copy();
1690      }
1691
1692      @Override
1693      public boolean equalsDeep(Base other_) {
1694        if (!super.equalsDeep(other_))
1695          return false;
1696        if (!(other_ instanceof ElementDefinitionSlicingDiscriminatorComponent))
1697          return false;
1698        ElementDefinitionSlicingDiscriminatorComponent o = (ElementDefinitionSlicingDiscriminatorComponent) other_;
1699        return compareDeep(type, o.type, true) && compareDeep(path, o.path, true);
1700      }
1701
1702      @Override
1703      public boolean equalsShallow(Base other_) {
1704        if (!super.equalsShallow(other_))
1705          return false;
1706        if (!(other_ instanceof ElementDefinitionSlicingDiscriminatorComponent))
1707          return false;
1708        ElementDefinitionSlicingDiscriminatorComponent o = (ElementDefinitionSlicingDiscriminatorComponent) other_;
1709        return compareValues(type, o.type, true) && compareValues(path, o.path, true);
1710      }
1711
1712      public boolean isEmpty() {
1713        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, path);
1714      }
1715
1716  public String fhirType() {
1717    return "ElementDefinition.slicing.discriminator";
1718
1719  }
1720
1721  @Override
1722  public String toString() {
1723    return (type == null ? "??" : type.getCode()) + "="+(path == null ? "??" : path.asStringValue());
1724  }
1725
1726  }
1727
1728    @Block()
1729    public static class ElementDefinitionBaseComponent extends Element implements IBaseDatatypeElement {
1730        /**
1731         * The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.
1732         */
1733        @Child(name = "path", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1734        @Description(shortDefinition="Path that identifies the base element", formalDefinition="The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base." )
1735        protected StringType path;
1736
1737        /**
1738         * Minimum cardinality of the base element identified by the path.
1739         */
1740        @Child(name = "min", type = {UnsignedIntType.class}, order=2, min=1, max=1, modifier=false, summary=true)
1741        @Description(shortDefinition="Min cardinality of the base element", formalDefinition="Minimum cardinality of the base element identified by the path." )
1742        protected UnsignedIntType min;
1743
1744        /**
1745         * Maximum cardinality of the base element identified by the path.
1746         */
1747        @Child(name = "max", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true)
1748        @Description(shortDefinition="Max cardinality of the base element", formalDefinition="Maximum cardinality of the base element identified by the path." )
1749        protected StringType max;
1750
1751        private static final long serialVersionUID = -1412704221L;
1752
1753    /**
1754     * Constructor
1755     */
1756      public ElementDefinitionBaseComponent() {
1757        super();
1758      }
1759
1760    /**
1761     * Constructor
1762     */
1763      public ElementDefinitionBaseComponent(String path, int min, String max) {
1764        super();
1765        this.setPath(path);
1766        this.setMin(min);
1767        this.setMax(max);
1768      }
1769
1770        /**
1771         * @return {@link #path} (The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
1772         */
1773        public StringType getPathElement() { 
1774          if (this.path == null)
1775            if (Configuration.errorOnAutoCreate())
1776              throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.path");
1777            else if (Configuration.doAutoCreate())
1778              this.path = new StringType(); // bb
1779          return this.path;
1780        }
1781
1782        public boolean hasPathElement() { 
1783          return this.path != null && !this.path.isEmpty();
1784        }
1785
1786        public boolean hasPath() { 
1787          return this.path != null && !this.path.isEmpty();
1788        }
1789
1790        /**
1791         * @param value {@link #path} (The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
1792         */
1793        public ElementDefinitionBaseComponent setPathElement(StringType value) { 
1794          this.path = value;
1795          return this;
1796        }
1797
1798        /**
1799         * @return The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.
1800         */
1801        public String getPath() { 
1802          return this.path == null ? null : this.path.getValue();
1803        }
1804
1805        /**
1806         * @param value The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.
1807         */
1808        public ElementDefinitionBaseComponent setPath(String value) { 
1809            if (this.path == null)
1810              this.path = new StringType();
1811            this.path.setValue(value);
1812          return this;
1813        }
1814
1815        /**
1816         * @return {@link #min} (Minimum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
1817         */
1818        public UnsignedIntType getMinElement() { 
1819          if (this.min == null)
1820            if (Configuration.errorOnAutoCreate())
1821              throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.min");
1822            else if (Configuration.doAutoCreate())
1823              this.min = new UnsignedIntType(); // bb
1824          return this.min;
1825        }
1826
1827        public boolean hasMinElement() { 
1828          return this.min != null && !this.min.isEmpty();
1829        }
1830
1831        public boolean hasMin() { 
1832          return this.min != null && !this.min.isEmpty();
1833        }
1834
1835        /**
1836         * @param value {@link #min} (Minimum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
1837         */
1838        public ElementDefinitionBaseComponent setMinElement(UnsignedIntType value) { 
1839          this.min = value;
1840          return this;
1841        }
1842
1843        /**
1844         * @return Minimum cardinality of the base element identified by the path.
1845         */
1846        public int getMin() { 
1847          return this.min == null || this.min.isEmpty() ? 0 : this.min.getValue();
1848        }
1849
1850        /**
1851         * @param value Minimum cardinality of the base element identified by the path.
1852         */
1853        public ElementDefinitionBaseComponent setMin(int value) { 
1854            if (this.min == null)
1855              this.min = new UnsignedIntType();
1856            this.min.setValue(value);
1857          return this;
1858        }
1859
1860        /**
1861         * @return {@link #max} (Maximum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
1862         */
1863        public StringType getMaxElement() { 
1864          if (this.max == null)
1865            if (Configuration.errorOnAutoCreate())
1866              throw new Error("Attempt to auto-create ElementDefinitionBaseComponent.max");
1867            else if (Configuration.doAutoCreate())
1868              this.max = new StringType(); // bb
1869          return this.max;
1870        }
1871
1872        public boolean hasMaxElement() { 
1873          return this.max != null && !this.max.isEmpty();
1874        }
1875
1876        public boolean hasMax() { 
1877          return this.max != null && !this.max.isEmpty();
1878        }
1879
1880        /**
1881         * @param value {@link #max} (Maximum cardinality of the base element identified by the path.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
1882         */
1883        public ElementDefinitionBaseComponent setMaxElement(StringType value) { 
1884          this.max = value;
1885          return this;
1886        }
1887
1888        /**
1889         * @return Maximum cardinality of the base element identified by the path.
1890         */
1891        public String getMax() { 
1892          return this.max == null ? null : this.max.getValue();
1893        }
1894
1895        /**
1896         * @param value Maximum cardinality of the base element identified by the path.
1897         */
1898        public ElementDefinitionBaseComponent setMax(String value) { 
1899            if (this.max == null)
1900              this.max = new StringType();
1901            this.max.setValue(value);
1902          return this;
1903        }
1904
1905        protected void listChildren(List<Property> children) {
1906          super.listChildren(children);
1907          children.add(new Property("path", "string", "The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.", 0, 1, path));
1908          children.add(new Property("min", "unsignedInt", "Minimum cardinality of the base element identified by the path.", 0, 1, min));
1909          children.add(new Property("max", "string", "Maximum cardinality of the base element identified by the path.", 0, 1, max));
1910        }
1911
1912        @Override
1913        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1914          switch (_hash) {
1915          case 3433509: /*path*/  return new Property("path", "string", "The Path that identifies the base element - this matches the ElementDefinition.path for that element. Across FHIR, there is only one base definition of any element - that is, an element definition on a [StructureDefinition](structuredefinition.html#) without a StructureDefinition.base.", 0, 1, path);
1916          case 108114: /*min*/  return new Property("min", "unsignedInt", "Minimum cardinality of the base element identified by the path.", 0, 1, min);
1917          case 107876: /*max*/  return new Property("max", "string", "Maximum cardinality of the base element identified by the path.", 0, 1, max);
1918          default: return super.getNamedProperty(_hash, _name, _checkValid);
1919          }
1920
1921        }
1922
1923      @Override
1924      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1925        switch (hash) {
1926        case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType
1927        case 108114: /*min*/ return this.min == null ? new Base[0] : new Base[] {this.min}; // UnsignedIntType
1928        case 107876: /*max*/ return this.max == null ? new Base[0] : new Base[] {this.max}; // StringType
1929        default: return super.getProperty(hash, name, checkValid);
1930        }
1931
1932      }
1933
1934      @Override
1935      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1936        switch (hash) {
1937        case 3433509: // path
1938          this.path = TypeConvertor.castToString(value); // StringType
1939          return value;
1940        case 108114: // min
1941          this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType
1942          return value;
1943        case 107876: // max
1944          this.max = TypeConvertor.castToString(value); // StringType
1945          return value;
1946        default: return super.setProperty(hash, name, value);
1947        }
1948
1949      }
1950
1951      @Override
1952      public Base setProperty(String name, Base value) throws FHIRException {
1953        if (name.equals("path")) {
1954          this.path = TypeConvertor.castToString(value); // StringType
1955        } else if (name.equals("min")) {
1956          this.min = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType
1957        } else if (name.equals("max")) {
1958          this.max = TypeConvertor.castToString(value); // StringType
1959        } else
1960          return super.setProperty(name, value);
1961        return value;
1962      }
1963
1964  @Override
1965  public void removeChild(String name, Base value) throws FHIRException {
1966        if (name.equals("path")) {
1967          this.path = null;
1968        } else if (name.equals("min")) {
1969          this.min = null;
1970        } else if (name.equals("max")) {
1971          this.max = null;
1972        } else
1973          super.removeChild(name, value);
1974        
1975      }
1976
1977      @Override
1978      public Base makeProperty(int hash, String name) throws FHIRException {
1979        switch (hash) {
1980        case 3433509:  return getPathElement();
1981        case 108114:  return getMinElement();
1982        case 107876:  return getMaxElement();
1983        default: return super.makeProperty(hash, name);
1984        }
1985
1986      }
1987
1988      @Override
1989      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1990        switch (hash) {
1991        case 3433509: /*path*/ return new String[] {"string"};
1992        case 108114: /*min*/ return new String[] {"unsignedInt"};
1993        case 107876: /*max*/ return new String[] {"string"};
1994        default: return super.getTypesForProperty(hash, name);
1995        }
1996
1997      }
1998
1999      @Override
2000      public Base addChild(String name) throws FHIRException {
2001        if (name.equals("path")) {
2002          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.base.path");
2003        }
2004        else if (name.equals("min")) {
2005          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.base.min");
2006        }
2007        else if (name.equals("max")) {
2008          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.base.max");
2009        }
2010        else
2011          return super.addChild(name);
2012      }
2013
2014      public ElementDefinitionBaseComponent copy() {
2015        ElementDefinitionBaseComponent dst = new ElementDefinitionBaseComponent();
2016        copyValues(dst);
2017        return dst;
2018      }
2019
2020      public void copyValues(ElementDefinitionBaseComponent dst) {
2021        super.copyValues(dst);
2022        dst.path = path == null ? null : path.copy();
2023        dst.min = min == null ? null : min.copy();
2024        dst.max = max == null ? null : max.copy();
2025      }
2026
2027      @Override
2028      public boolean equalsDeep(Base other_) {
2029        if (!super.equalsDeep(other_))
2030          return false;
2031        if (!(other_ instanceof ElementDefinitionBaseComponent))
2032          return false;
2033        ElementDefinitionBaseComponent o = (ElementDefinitionBaseComponent) other_;
2034        return compareDeep(path, o.path, true) && compareDeep(min, o.min, true) && compareDeep(max, o.max, true)
2035          ;
2036      }
2037
2038      @Override
2039      public boolean equalsShallow(Base other_) {
2040        if (!super.equalsShallow(other_))
2041          return false;
2042        if (!(other_ instanceof ElementDefinitionBaseComponent))
2043          return false;
2044        ElementDefinitionBaseComponent o = (ElementDefinitionBaseComponent) other_;
2045        return compareValues(path, o.path, true) && compareValues(min, o.min, true) && compareValues(max, o.max, true)
2046          ;
2047      }
2048
2049      public boolean isEmpty() {
2050        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(path, min, max);
2051      }
2052
2053  public String fhirType() {
2054    return "ElementDefinition.base";
2055
2056  }
2057
2058  }
2059
2060    @Block()
2061    public static class TypeRefComponent extends Element implements IBaseDatatypeElement {
2062        /**
2063         * URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
2064         */
2065        @Child(name = "code", type = {UriType.class}, order=1, min=1, max=1, modifier=false, summary=true)
2066        @Description(shortDefinition="Data type or Resource (reference to definition)", formalDefinition="URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models." )
2067        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/elementdefinition-types")
2068        protected UriType code;
2069
2070        /**
2071         * Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.
2072         */
2073        @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2074        @Description(shortDefinition="Profiles (StructureDefinition or IG) - one must apply", formalDefinition="Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide." )
2075        protected List<CanonicalType> profile;
2076
2077        /**
2078         * Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.
2079         */
2080        @Child(name = "targetProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2081        @Description(shortDefinition="Profile (StructureDefinition or IG) on the Reference/canonical target - one must apply", formalDefinition="Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide." )
2082        protected List<CanonicalType> targetProfile;
2083
2084        /**
2085         * If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.
2086         */
2087        @Child(name = "aggregation", type = {CodeType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2088        @Description(shortDefinition="contained | referenced | bundled - how aggregated", formalDefinition="If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle." )
2089        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-aggregation-mode")
2090        protected List<Enumeration<AggregationMode>> aggregation;
2091
2092        /**
2093         * Whether this reference needs to be version specific or version independent, or whether either can be used.
2094         */
2095        @Child(name = "versioning", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=true)
2096        @Description(shortDefinition="either | independent | specific", formalDefinition="Whether this reference needs to be version specific or version independent, or whether either can be used." )
2097        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reference-version-rules")
2098        protected Enumeration<ReferenceVersionRules> versioning;
2099
2100        private static final long serialVersionUID = 957891653L;
2101
2102    /**
2103     * Constructor
2104     */
2105      public TypeRefComponent() {
2106        super();
2107      }
2108
2109    /**
2110     * Constructor
2111     */
2112      public TypeRefComponent(String code) {
2113        super();
2114        this.setCode(code);
2115      }
2116
2117        /**
2118         * @return {@link #code} (URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2119         */
2120        public UriType getCodeElement() { 
2121          if (this.code == null)
2122            if (Configuration.errorOnAutoCreate())
2123              throw new Error("Attempt to auto-create TypeRefComponent.code");
2124            else if (Configuration.doAutoCreate())
2125              this.code = new UriType(); // bb
2126          return this.code;
2127        }
2128
2129        public boolean hasCodeElement() { 
2130          return this.code != null && !this.code.isEmpty();
2131        }
2132
2133        public boolean hasCode() { 
2134          return this.code != null && !this.code.isEmpty();
2135        }
2136
2137        /**
2138         * @param value {@link #code} (URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2139         */
2140        public TypeRefComponent setCodeElement(UriType value) { 
2141          this.code = value;
2142          return this;
2143        }
2144
2145        /**
2146         * @return URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
2147         */
2148        public String getCode() { 
2149          return this.code == null ? null : this.code.getValue();
2150        }
2151
2152        /**
2153         * @param value URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
2154         */
2155        public TypeRefComponent setCode(String value) { 
2156            if (this.code == null)
2157              this.code = new UriType();
2158            this.code.setValue(value);
2159          return this;
2160        }
2161
2162        /**
2163         * @return {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.)
2164         */
2165        public List<CanonicalType> getProfile() { 
2166          if (this.profile == null)
2167            this.profile = new ArrayList<CanonicalType>();
2168          return this.profile;
2169        }
2170
2171        /**
2172         * @return Returns a reference to <code>this</code> for easy method chaining
2173         */
2174        public TypeRefComponent setProfile(List<CanonicalType> theProfile) { 
2175          this.profile = theProfile;
2176          return this;
2177        }
2178
2179        public boolean hasProfile() { 
2180          if (this.profile == null)
2181            return false;
2182          for (CanonicalType item : this.profile)
2183            if (!item.isEmpty())
2184              return true;
2185          return false;
2186        }
2187
2188        /**
2189         * @return {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.)
2190         */
2191        public CanonicalType addProfileElement() {//2 
2192          CanonicalType t = new CanonicalType();
2193          if (this.profile == null)
2194            this.profile = new ArrayList<CanonicalType>();
2195          this.profile.add(t);
2196          return t;
2197        }
2198
2199        /**
2200         * @param value {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.)
2201         */
2202        public TypeRefComponent addProfile(String value) { //1
2203          CanonicalType t = new CanonicalType();
2204          t.setValue(value);
2205          if (this.profile == null)
2206            this.profile = new ArrayList<CanonicalType>();
2207          this.profile.add(t);
2208          return this;
2209        }
2210
2211        /**
2212         * @param value {@link #profile} (Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.)
2213         */
2214        public boolean hasProfile(String value) { 
2215          if (this.profile == null)
2216            return false;
2217          for (CanonicalType v : this.profile)
2218            if (v.getValue().equals(value)) // canonical
2219              return true;
2220          return false;
2221        }
2222
2223        /**
2224         * @return {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.)
2225         */
2226        public List<CanonicalType> getTargetProfile() { 
2227          if (this.targetProfile == null)
2228            this.targetProfile = new ArrayList<CanonicalType>();
2229          return this.targetProfile;
2230        }
2231
2232        /**
2233         * @return Returns a reference to <code>this</code> for easy method chaining
2234         */
2235        public TypeRefComponent setTargetProfile(List<CanonicalType> theTargetProfile) { 
2236          this.targetProfile = theTargetProfile;
2237          return this;
2238        }
2239
2240        public boolean hasTargetProfile() { 
2241          if (this.targetProfile == null)
2242            return false;
2243          for (CanonicalType item : this.targetProfile)
2244            if (!item.isEmpty())
2245              return true;
2246          return false;
2247        }
2248
2249        /**
2250         * @return {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.)
2251         */
2252        public CanonicalType addTargetProfileElement() {//2 
2253          CanonicalType t = new CanonicalType();
2254          if (this.targetProfile == null)
2255            this.targetProfile = new ArrayList<CanonicalType>();
2256          this.targetProfile.add(t);
2257          return t;
2258        }
2259
2260        /**
2261         * @param value {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.)
2262         */
2263        public TypeRefComponent addTargetProfile(String value) { //1
2264          CanonicalType t = new CanonicalType();
2265          t.setValue(value);
2266          if (this.targetProfile == null)
2267            this.targetProfile = new ArrayList<CanonicalType>();
2268          this.targetProfile.add(t);
2269          return this;
2270        }
2271
2272        /**
2273         * @param value {@link #targetProfile} (Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.)
2274         */
2275        public boolean hasTargetProfile(String value) { 
2276          if (this.targetProfile == null)
2277            return false;
2278          for (CanonicalType v : this.targetProfile)
2279            if (v.getValue().equals(value)) // canonical
2280              return true;
2281          return false;
2282        }
2283
2284        /**
2285         * @return {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.)
2286         */
2287        public List<Enumeration<AggregationMode>> getAggregation() { 
2288          if (this.aggregation == null)
2289            this.aggregation = new ArrayList<Enumeration<AggregationMode>>();
2290          return this.aggregation;
2291        }
2292
2293        /**
2294         * @return Returns a reference to <code>this</code> for easy method chaining
2295         */
2296        public TypeRefComponent setAggregation(List<Enumeration<AggregationMode>> theAggregation) { 
2297          this.aggregation = theAggregation;
2298          return this;
2299        }
2300
2301        public boolean hasAggregation() { 
2302          if (this.aggregation == null)
2303            return false;
2304          for (Enumeration<AggregationMode> item : this.aggregation)
2305            if (!item.isEmpty())
2306              return true;
2307          return false;
2308        }
2309
2310        /**
2311         * @return {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.)
2312         */
2313        public Enumeration<AggregationMode> addAggregationElement() {//2 
2314          Enumeration<AggregationMode> t = new Enumeration<AggregationMode>(new AggregationModeEnumFactory());
2315          if (this.aggregation == null)
2316            this.aggregation = new ArrayList<Enumeration<AggregationMode>>();
2317          this.aggregation.add(t);
2318          return t;
2319        }
2320
2321        /**
2322         * @param value {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.)
2323         */
2324        public TypeRefComponent addAggregation(AggregationMode value) { //1
2325          Enumeration<AggregationMode> t = new Enumeration<AggregationMode>(new AggregationModeEnumFactory());
2326          t.setValue(value);
2327          if (this.aggregation == null)
2328            this.aggregation = new ArrayList<Enumeration<AggregationMode>>();
2329          this.aggregation.add(t);
2330          return this;
2331        }
2332
2333        /**
2334         * @param value {@link #aggregation} (If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.)
2335         */
2336        public boolean hasAggregation(AggregationMode value) { 
2337          if (this.aggregation == null)
2338            return false;
2339          for (Enumeration<AggregationMode> v : this.aggregation)
2340            if (v.getValue().equals(value)) // code
2341              return true;
2342          return false;
2343        }
2344
2345        /**
2346         * @return {@link #versioning} (Whether this reference needs to be version specific or version independent, or whether either can be used.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value
2347         */
2348        public Enumeration<ReferenceVersionRules> getVersioningElement() { 
2349          if (this.versioning == null)
2350            if (Configuration.errorOnAutoCreate())
2351              throw new Error("Attempt to auto-create TypeRefComponent.versioning");
2352            else if (Configuration.doAutoCreate())
2353              this.versioning = new Enumeration<ReferenceVersionRules>(new ReferenceVersionRulesEnumFactory()); // bb
2354          return this.versioning;
2355        }
2356
2357        public boolean hasVersioningElement() { 
2358          return this.versioning != null && !this.versioning.isEmpty();
2359        }
2360
2361        public boolean hasVersioning() { 
2362          return this.versioning != null && !this.versioning.isEmpty();
2363        }
2364
2365        /**
2366         * @param value {@link #versioning} (Whether this reference needs to be version specific or version independent, or whether either can be used.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value
2367         */
2368        public TypeRefComponent setVersioningElement(Enumeration<ReferenceVersionRules> value) { 
2369          this.versioning = value;
2370          return this;
2371        }
2372
2373        /**
2374         * @return Whether this reference needs to be version specific or version independent, or whether either can be used.
2375         */
2376        public ReferenceVersionRules getVersioning() { 
2377          return this.versioning == null ? null : this.versioning.getValue();
2378        }
2379
2380        /**
2381         * @param value Whether this reference needs to be version specific or version independent, or whether either can be used.
2382         */
2383        public TypeRefComponent setVersioning(ReferenceVersionRules value) { 
2384          if (value == null)
2385            this.versioning = null;
2386          else {
2387            if (this.versioning == null)
2388              this.versioning = new Enumeration<ReferenceVersionRules>(new ReferenceVersionRulesEnumFactory());
2389            this.versioning.setValue(value);
2390          }
2391          return this;
2392        }
2393
2394        protected void listChildren(List<Property> children) {
2395          super.listChildren(children);
2396          children.add(new Property("code", "uri", "URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, code));
2397          children.add(new Property("profile", "canonical(StructureDefinition|ImplementationGuide)", "Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, profile));
2398          children.add(new Property("targetProfile", "canonical(StructureDefinition|ImplementationGuide)", "Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, targetProfile));
2399          children.add(new Property("aggregation", "code", "If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.", 0, java.lang.Integer.MAX_VALUE, aggregation));
2400          children.add(new Property("versioning", "code", "Whether this reference needs to be version specific or version independent, or whether either can be used.", 0, 1, versioning));
2401        }
2402
2403        @Override
2404        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2405          switch (_hash) {
2406          case 3059181: /*code*/  return new Property("code", "uri", "URL of Data type or Resource that is a(or the) type used for this element. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, code);
2407          case -309425751: /*profile*/  return new Property("profile", "canonical(StructureDefinition|ImplementationGuide)", "Identifies a profile structure or implementation Guide that applies to the datatype this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the type SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, profile);
2408          case 1994521304: /*targetProfile*/  return new Property("targetProfile", "canonical(StructureDefinition|ImplementationGuide)", "Used when the type is \"Reference\" or \"canonical\", and identifies a profile structure or implementation Guide that applies to the target of the reference this element refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.", 0, java.lang.Integer.MAX_VALUE, targetProfile);
2409          case 841524962: /*aggregation*/  return new Property("aggregation", "code", "If the type is a reference to another resource, how the resource is or can be aggregated - is it a contained resource, or a reference, and if the context is a bundle, is it included in the bundle.", 0, java.lang.Integer.MAX_VALUE, aggregation);
2410          case -670487542: /*versioning*/  return new Property("versioning", "code", "Whether this reference needs to be version specific or version independent, or whether either can be used.", 0, 1, versioning);
2411          default: return super.getNamedProperty(_hash, _name, _checkValid);
2412          }
2413
2414        }
2415
2416      @Override
2417      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2418        switch (hash) {
2419        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // UriType
2420        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : this.profile.toArray(new Base[this.profile.size()]); // CanonicalType
2421        case 1994521304: /*targetProfile*/ return this.targetProfile == null ? new Base[0] : this.targetProfile.toArray(new Base[this.targetProfile.size()]); // CanonicalType
2422        case 841524962: /*aggregation*/ return this.aggregation == null ? new Base[0] : this.aggregation.toArray(new Base[this.aggregation.size()]); // Enumeration<AggregationMode>
2423        case -670487542: /*versioning*/ return this.versioning == null ? new Base[0] : new Base[] {this.versioning}; // Enumeration<ReferenceVersionRules>
2424        default: return super.getProperty(hash, name, checkValid);
2425        }
2426
2427      }
2428
2429      @Override
2430      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2431        switch (hash) {
2432        case 3059181: // code
2433          this.code = TypeConvertor.castToUri(value); // UriType
2434          return value;
2435        case -309425751: // profile
2436          this.getProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType
2437          return value;
2438        case 1994521304: // targetProfile
2439          this.getTargetProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType
2440          return value;
2441        case 841524962: // aggregation
2442          value = new AggregationModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2443          this.getAggregation().add((Enumeration) value); // Enumeration<AggregationMode>
2444          return value;
2445        case -670487542: // versioning
2446          value = new ReferenceVersionRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
2447          this.versioning = (Enumeration) value; // Enumeration<ReferenceVersionRules>
2448          return value;
2449        default: return super.setProperty(hash, name, value);
2450        }
2451
2452      }
2453
2454      @Override
2455      public Base setProperty(String name, Base value) throws FHIRException {
2456        if (name.equals("code")) {
2457          this.code = TypeConvertor.castToUri(value); // UriType
2458        } else if (name.equals("profile")) {
2459          this.getProfile().add(TypeConvertor.castToCanonical(value));
2460        } else if (name.equals("targetProfile")) {
2461          this.getTargetProfile().add(TypeConvertor.castToCanonical(value));
2462        } else if (name.equals("aggregation")) {
2463          value = new AggregationModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2464          this.getAggregation().add((Enumeration) value);
2465        } else if (name.equals("versioning")) {
2466          value = new ReferenceVersionRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
2467          this.versioning = (Enumeration) value; // Enumeration<ReferenceVersionRules>
2468        } else
2469          return super.setProperty(name, value);
2470        return value;
2471      }
2472
2473  @Override
2474  public void removeChild(String name, Base value) throws FHIRException {
2475        if (name.equals("code")) {
2476          this.code = null;
2477        } else if (name.equals("profile")) {
2478          this.getProfile().remove(value);
2479        } else if (name.equals("targetProfile")) {
2480          this.getTargetProfile().remove(value);
2481        } else if (name.equals("aggregation")) {
2482          value = new AggregationModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2483          this.getAggregation().remove((Enumeration) value);
2484        } else if (name.equals("versioning")) {
2485          value = new ReferenceVersionRulesEnumFactory().fromType(TypeConvertor.castToCode(value));
2486          this.versioning = (Enumeration) value; // Enumeration<ReferenceVersionRules>
2487        } else
2488          super.removeChild(name, value);
2489        
2490      }
2491
2492      @Override
2493      public Base makeProperty(int hash, String name) throws FHIRException {
2494        switch (hash) {
2495        case 3059181:  return getCodeElement();
2496        case -309425751:  return addProfileElement();
2497        case 1994521304:  return addTargetProfileElement();
2498        case 841524962:  return addAggregationElement();
2499        case -670487542:  return getVersioningElement();
2500        default: return super.makeProperty(hash, name);
2501        }
2502
2503      }
2504
2505      @Override
2506      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2507        switch (hash) {
2508        case 3059181: /*code*/ return new String[] {"uri"};
2509        case -309425751: /*profile*/ return new String[] {"canonical"};
2510        case 1994521304: /*targetProfile*/ return new String[] {"canonical"};
2511        case 841524962: /*aggregation*/ return new String[] {"code"};
2512        case -670487542: /*versioning*/ return new String[] {"code"};
2513        default: return super.getTypesForProperty(hash, name);
2514        }
2515
2516      }
2517
2518      @Override
2519      public Base addChild(String name) throws FHIRException {
2520        if (name.equals("code")) {
2521          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.type.code");
2522        }
2523        else if (name.equals("profile")) {
2524          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.type.profile");
2525        }
2526        else if (name.equals("targetProfile")) {
2527          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.type.targetProfile");
2528        }
2529        else if (name.equals("aggregation")) {
2530          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.type.aggregation");
2531        }
2532        else if (name.equals("versioning")) {
2533          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.type.versioning");
2534        }
2535        else
2536          return super.addChild(name);
2537      }
2538
2539      public TypeRefComponent copy() {
2540        TypeRefComponent dst = new TypeRefComponent();
2541        copyValues(dst);
2542        return dst;
2543      }
2544
2545      public void copyValues(TypeRefComponent dst) {
2546        super.copyValues(dst);
2547        dst.code = code == null ? null : code.copy();
2548        if (profile != null) {
2549          dst.profile = new ArrayList<CanonicalType>();
2550          for (CanonicalType i : profile)
2551            dst.profile.add(i.copy());
2552        };
2553        if (targetProfile != null) {
2554          dst.targetProfile = new ArrayList<CanonicalType>();
2555          for (CanonicalType i : targetProfile)
2556            dst.targetProfile.add(i.copy());
2557        };
2558        if (aggregation != null) {
2559          dst.aggregation = new ArrayList<Enumeration<AggregationMode>>();
2560          for (Enumeration<AggregationMode> i : aggregation)
2561            dst.aggregation.add(i.copy());
2562        };
2563        dst.versioning = versioning == null ? null : versioning.copy();
2564      }
2565
2566      @Override
2567      public boolean equalsDeep(Base other_) {
2568        if (!super.equalsDeep(other_))
2569          return false;
2570        if (!(other_ instanceof TypeRefComponent))
2571          return false;
2572        TypeRefComponent o = (TypeRefComponent) other_;
2573        return compareDeep(code, o.code, true) && compareDeep(profile, o.profile, true) && compareDeep(targetProfile, o.targetProfile, true)
2574           && compareDeep(aggregation, o.aggregation, true) && compareDeep(versioning, o.versioning, true)
2575          ;
2576      }
2577
2578      @Override
2579      public boolean equalsShallow(Base other_) {
2580        if (!super.equalsShallow(other_))
2581          return false;
2582        if (!(other_ instanceof TypeRefComponent))
2583          return false;
2584        TypeRefComponent o = (TypeRefComponent) other_;
2585        return compareValues(code, o.code, true) && compareValues(profile, o.profile, true) && compareValues(targetProfile, o.targetProfile, true)
2586           && compareValues(aggregation, o.aggregation, true) && compareValues(versioning, o.versioning, true)
2587          ;
2588      }
2589
2590      public boolean isEmpty() {
2591        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, profile, targetProfile
2592          , aggregation, versioning);
2593      }
2594
2595  public String fhirType() {
2596    return "ElementDefinition.type";
2597
2598  }
2599
2600// added from java-adornments.txt:
2601public boolean hasTarget() {
2602    return Utilities.existsInList(getCode(), "Reference", "canonical", "CodeableReference");
2603  }
2604  
2605    /**
2606   * This code checks for the system prefix and returns the FHIR type
2607   * 
2608   * @return
2609   */
2610  public String getWorkingCode() {
2611    if (hasExtension(ToolingExtensions.EXT_FHIR_TYPE))
2612      return getExtensionString(ToolingExtensions.EXT_FHIR_TYPE);
2613    if (!hasCodeElement()) 
2614      return null;
2615    if (getCodeElement().hasExtension(ToolingExtensions.EXT_XML_TYPE)) {
2616      String s = getCodeElement().getExtensionString(ToolingExtensions.EXT_XML_TYPE);
2617      if ("xsd:gYear OR xsd:gYearMonth OR xsd:date OR xsd:dateTime".equalsIgnoreCase(s))
2618        return "dateTime";
2619      if ("xsd:gYear OR xsd:gYearMonth OR xsd:date".equalsIgnoreCase(s))
2620        return "date";
2621      if ("xsd:dateTime".equalsIgnoreCase(s))
2622        return "instant";
2623      if ("xsd:token".equals(s))
2624        return "code";
2625      if ("xsd:boolean".equals(s))
2626        return "boolean";
2627      if ("xsd:string".equals(s))
2628        return "string";
2629      if ("xsd:time".equals(s))
2630        return "time";
2631      if ("xsd:int".equals(s))
2632        return "integer";
2633      if ("xsd:decimal OR xsd:double".equals(s))
2634        return "decimal";
2635      if ("xsd:decimal".equalsIgnoreCase(s))
2636        return "decimal";
2637      if ("xsd:base64Binary".equalsIgnoreCase(s))
2638        return "base64Binary";
2639      if ("xsd:positiveInteger".equalsIgnoreCase(s))
2640        return "positiveInt";
2641      if ("xsd:nonNegativeInteger".equalsIgnoreCase(s))
2642        return "unsignedInt";
2643      if ("xsd:anyURI".equalsIgnoreCase(s))
2644        return "uri";
2645      if ("xhtml:div".equalsIgnoreCase(s))
2646        return "xhtml";
2647      
2648      throw new Error("Unknown xml type '"+s+"'");
2649    }
2650    return getCode();
2651  }
2652
2653  @Override
2654  public String toString() {
2655    String res = getCode();
2656    if (hasProfile()) {
2657      res = res + "{";
2658      boolean first = true;
2659      for (CanonicalType s : getProfile()) {
2660        if (first) first = false; else res = res + "|";
2661        res = res + s.getValue();
2662      }
2663      res = res + "}";
2664    }
2665    if (hasTargetProfile()) {
2666      res = res + "(";
2667      boolean first = true;
2668      for (CanonicalType s : getTargetProfile()) {
2669        if (first) first = false; else res = res + "|";
2670        res = res + s.getValue();
2671      }
2672      res = res + ")";
2673    }    
2674    return res;
2675  }
2676
2677  public String getName() {
2678    return getWorkingCode();
2679  }
2680
2681  public boolean isResourceReference() {
2682    return "Reference".equals(getCode()) && hasTargetProfile();
2683  }
2684// end addition
2685  }
2686
2687    @Block()
2688    public static class ElementDefinitionExampleComponent extends Element implements IBaseDatatypeElement {
2689        /**
2690         * Describes the purpose of this example among the set of examples.
2691         */
2692        @Child(name = "label", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
2693        @Description(shortDefinition="Describes the purpose of this example", formalDefinition="Describes the purpose of this example among the set of examples." )
2694        protected StringType label;
2695
2696        /**
2697         * The actual value for the element, which must be one of the types allowed for this element.
2698         */
2699        @Child(name = "value", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, CodeableReference.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, RatioRange.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Availability.class, ExtendedContactDetail.class, Dosage.class, Meta.class}, order=2, min=1, max=1, modifier=false, summary=true)
2700        @Description(shortDefinition="Value of Example (one of allowed types)", formalDefinition="The actual value for the element, which must be one of the types allowed for this element." )
2701        protected DataType value;
2702
2703        private static final long serialVersionUID = 463190922L;
2704
2705    /**
2706     * Constructor
2707     */
2708      public ElementDefinitionExampleComponent() {
2709        super();
2710      }
2711
2712    /**
2713     * Constructor
2714     */
2715      public ElementDefinitionExampleComponent(String label, DataType value) {
2716        super();
2717        this.setLabel(label);
2718        this.setValue(value);
2719      }
2720
2721        /**
2722         * @return {@link #label} (Describes the purpose of this example among the set of examples.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
2723         */
2724        public StringType getLabelElement() { 
2725          if (this.label == null)
2726            if (Configuration.errorOnAutoCreate())
2727              throw new Error("Attempt to auto-create ElementDefinitionExampleComponent.label");
2728            else if (Configuration.doAutoCreate())
2729              this.label = new StringType(); // bb
2730          return this.label;
2731        }
2732
2733        public boolean hasLabelElement() { 
2734          return this.label != null && !this.label.isEmpty();
2735        }
2736
2737        public boolean hasLabel() { 
2738          return this.label != null && !this.label.isEmpty();
2739        }
2740
2741        /**
2742         * @param value {@link #label} (Describes the purpose of this example among the set of examples.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
2743         */
2744        public ElementDefinitionExampleComponent setLabelElement(StringType value) { 
2745          this.label = value;
2746          return this;
2747        }
2748
2749        /**
2750         * @return Describes the purpose of this example among the set of examples.
2751         */
2752        public String getLabel() { 
2753          return this.label == null ? null : this.label.getValue();
2754        }
2755
2756        /**
2757         * @param value Describes the purpose of this example among the set of examples.
2758         */
2759        public ElementDefinitionExampleComponent setLabel(String value) { 
2760            if (this.label == null)
2761              this.label = new StringType();
2762            this.label.setValue(value);
2763          return this;
2764        }
2765
2766        /**
2767         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2768         */
2769        public DataType getValue() { 
2770          return this.value;
2771        }
2772
2773        /**
2774         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2775         */
2776        public Base64BinaryType getValueBase64BinaryType() throws FHIRException { 
2777          if (this.value == null)
2778            this.value = new Base64BinaryType();
2779          if (!(this.value instanceof Base64BinaryType))
2780            throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.value.getClass().getName()+" was encountered");
2781          return (Base64BinaryType) this.value;
2782        }
2783
2784        public boolean hasValueBase64BinaryType() { 
2785          return this != null && this.value instanceof Base64BinaryType;
2786        }
2787
2788        /**
2789         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2790         */
2791        public BooleanType getValueBooleanType() throws FHIRException { 
2792          if (this.value == null)
2793            this.value = new BooleanType();
2794          if (!(this.value instanceof BooleanType))
2795            throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered");
2796          return (BooleanType) this.value;
2797        }
2798
2799        public boolean hasValueBooleanType() { 
2800          return this != null && this.value instanceof BooleanType;
2801        }
2802
2803        /**
2804         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2805         */
2806        public CanonicalType getValueCanonicalType() throws FHIRException { 
2807          if (this.value == null)
2808            this.value = new CanonicalType();
2809          if (!(this.value instanceof CanonicalType))
2810            throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.value.getClass().getName()+" was encountered");
2811          return (CanonicalType) this.value;
2812        }
2813
2814        public boolean hasValueCanonicalType() { 
2815          return this != null && this.value instanceof CanonicalType;
2816        }
2817
2818        /**
2819         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2820         */
2821        public CodeType getValueCodeType() throws FHIRException { 
2822          if (this.value == null)
2823            this.value = new CodeType();
2824          if (!(this.value instanceof CodeType))
2825            throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.value.getClass().getName()+" was encountered");
2826          return (CodeType) this.value;
2827        }
2828
2829        public boolean hasValueCodeType() { 
2830          return this != null && this.value instanceof CodeType;
2831        }
2832
2833        /**
2834         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2835         */
2836        public DateType getValueDateType() throws FHIRException { 
2837          if (this.value == null)
2838            this.value = new DateType();
2839          if (!(this.value instanceof DateType))
2840            throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.value.getClass().getName()+" was encountered");
2841          return (DateType) this.value;
2842        }
2843
2844        public boolean hasValueDateType() { 
2845          return this != null && this.value instanceof DateType;
2846        }
2847
2848        /**
2849         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2850         */
2851        public DateTimeType getValueDateTimeType() throws FHIRException { 
2852          if (this.value == null)
2853            this.value = new DateTimeType();
2854          if (!(this.value instanceof DateTimeType))
2855            throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.value.getClass().getName()+" was encountered");
2856          return (DateTimeType) this.value;
2857        }
2858
2859        public boolean hasValueDateTimeType() { 
2860          return this != null && this.value instanceof DateTimeType;
2861        }
2862
2863        /**
2864         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2865         */
2866        public DecimalType getValueDecimalType() throws FHIRException { 
2867          if (this.value == null)
2868            this.value = new DecimalType();
2869          if (!(this.value instanceof DecimalType))
2870            throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.value.getClass().getName()+" was encountered");
2871          return (DecimalType) this.value;
2872        }
2873
2874        public boolean hasValueDecimalType() { 
2875          return this != null && this.value instanceof DecimalType;
2876        }
2877
2878        /**
2879         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2880         */
2881        public IdType getValueIdType() throws FHIRException { 
2882          if (this.value == null)
2883            this.value = new IdType();
2884          if (!(this.value instanceof IdType))
2885            throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.value.getClass().getName()+" was encountered");
2886          return (IdType) this.value;
2887        }
2888
2889        public boolean hasValueIdType() { 
2890          return this != null && this.value instanceof IdType;
2891        }
2892
2893        /**
2894         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2895         */
2896        public InstantType getValueInstantType() throws FHIRException { 
2897          if (this.value == null)
2898            this.value = new InstantType();
2899          if (!(this.value instanceof InstantType))
2900            throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.value.getClass().getName()+" was encountered");
2901          return (InstantType) this.value;
2902        }
2903
2904        public boolean hasValueInstantType() { 
2905          return this != null && this.value instanceof InstantType;
2906        }
2907
2908        /**
2909         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2910         */
2911        public IntegerType getValueIntegerType() throws FHIRException { 
2912          if (this.value == null)
2913            this.value = new IntegerType();
2914          if (!(this.value instanceof IntegerType))
2915            throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered");
2916          return (IntegerType) this.value;
2917        }
2918
2919        public boolean hasValueIntegerType() { 
2920          return this != null && this.value instanceof IntegerType;
2921        }
2922
2923        /**
2924         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2925         */
2926        public Integer64Type getValueInteger64Type() throws FHIRException { 
2927          if (this.value == null)
2928            this.value = new Integer64Type();
2929          if (!(this.value instanceof Integer64Type))
2930            throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.value.getClass().getName()+" was encountered");
2931          return (Integer64Type) this.value;
2932        }
2933
2934        public boolean hasValueInteger64Type() { 
2935          return this != null && this.value instanceof Integer64Type;
2936        }
2937
2938        /**
2939         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2940         */
2941        public MarkdownType getValueMarkdownType() throws FHIRException { 
2942          if (this.value == null)
2943            this.value = new MarkdownType();
2944          if (!(this.value instanceof MarkdownType))
2945            throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.value.getClass().getName()+" was encountered");
2946          return (MarkdownType) this.value;
2947        }
2948
2949        public boolean hasValueMarkdownType() { 
2950          return this != null && this.value instanceof MarkdownType;
2951        }
2952
2953        /**
2954         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2955         */
2956        public OidType getValueOidType() throws FHIRException { 
2957          if (this.value == null)
2958            this.value = new OidType();
2959          if (!(this.value instanceof OidType))
2960            throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.value.getClass().getName()+" was encountered");
2961          return (OidType) this.value;
2962        }
2963
2964        public boolean hasValueOidType() { 
2965          return this != null && this.value instanceof OidType;
2966        }
2967
2968        /**
2969         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2970         */
2971        public PositiveIntType getValuePositiveIntType() throws FHIRException { 
2972          if (this.value == null)
2973            this.value = new PositiveIntType();
2974          if (!(this.value instanceof PositiveIntType))
2975            throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.value.getClass().getName()+" was encountered");
2976          return (PositiveIntType) this.value;
2977        }
2978
2979        public boolean hasValuePositiveIntType() { 
2980          return this != null && this.value instanceof PositiveIntType;
2981        }
2982
2983        /**
2984         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
2985         */
2986        public StringType getValueStringType() throws FHIRException { 
2987          if (this.value == null)
2988            this.value = new StringType();
2989          if (!(this.value instanceof StringType))
2990            throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered");
2991          return (StringType) this.value;
2992        }
2993
2994        public boolean hasValueStringType() { 
2995          return this != null && this.value instanceof StringType;
2996        }
2997
2998        /**
2999         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3000         */
3001        public TimeType getValueTimeType() throws FHIRException { 
3002          if (this.value == null)
3003            this.value = new TimeType();
3004          if (!(this.value instanceof TimeType))
3005            throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.value.getClass().getName()+" was encountered");
3006          return (TimeType) this.value;
3007        }
3008
3009        public boolean hasValueTimeType() { 
3010          return this != null && this.value instanceof TimeType;
3011        }
3012
3013        /**
3014         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3015         */
3016        public UnsignedIntType getValueUnsignedIntType() throws FHIRException { 
3017          if (this.value == null)
3018            this.value = new UnsignedIntType();
3019          if (!(this.value instanceof UnsignedIntType))
3020            throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.value.getClass().getName()+" was encountered");
3021          return (UnsignedIntType) this.value;
3022        }
3023
3024        public boolean hasValueUnsignedIntType() { 
3025          return this != null && this.value instanceof UnsignedIntType;
3026        }
3027
3028        /**
3029         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3030         */
3031        public UriType getValueUriType() throws FHIRException { 
3032          if (this.value == null)
3033            this.value = new UriType();
3034          if (!(this.value instanceof UriType))
3035            throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.value.getClass().getName()+" was encountered");
3036          return (UriType) this.value;
3037        }
3038
3039        public boolean hasValueUriType() { 
3040          return this != null && this.value instanceof UriType;
3041        }
3042
3043        /**
3044         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3045         */
3046        public UrlType getValueUrlType() throws FHIRException { 
3047          if (this.value == null)
3048            this.value = new UrlType();
3049          if (!(this.value instanceof UrlType))
3050            throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.value.getClass().getName()+" was encountered");
3051          return (UrlType) this.value;
3052        }
3053
3054        public boolean hasValueUrlType() { 
3055          return this != null && this.value instanceof UrlType;
3056        }
3057
3058        /**
3059         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3060         */
3061        public UuidType getValueUuidType() throws FHIRException { 
3062          if (this.value == null)
3063            this.value = new UuidType();
3064          if (!(this.value instanceof UuidType))
3065            throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.value.getClass().getName()+" was encountered");
3066          return (UuidType) this.value;
3067        }
3068
3069        public boolean hasValueUuidType() { 
3070          return this != null && this.value instanceof UuidType;
3071        }
3072
3073        /**
3074         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3075         */
3076        public Address getValueAddress() throws FHIRException { 
3077          if (this.value == null)
3078            this.value = new Address();
3079          if (!(this.value instanceof Address))
3080            throw new FHIRException("Type mismatch: the type Address was expected, but "+this.value.getClass().getName()+" was encountered");
3081          return (Address) this.value;
3082        }
3083
3084        public boolean hasValueAddress() { 
3085          return this != null && this.value instanceof Address;
3086        }
3087
3088        /**
3089         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3090         */
3091        public Age getValueAge() throws FHIRException { 
3092          if (this.value == null)
3093            this.value = new Age();
3094          if (!(this.value instanceof Age))
3095            throw new FHIRException("Type mismatch: the type Age was expected, but "+this.value.getClass().getName()+" was encountered");
3096          return (Age) this.value;
3097        }
3098
3099        public boolean hasValueAge() { 
3100          return this != null && this.value instanceof Age;
3101        }
3102
3103        /**
3104         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3105         */
3106        public Annotation getValueAnnotation() throws FHIRException { 
3107          if (this.value == null)
3108            this.value = new Annotation();
3109          if (!(this.value instanceof Annotation))
3110            throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.value.getClass().getName()+" was encountered");
3111          return (Annotation) this.value;
3112        }
3113
3114        public boolean hasValueAnnotation() { 
3115          return this != null && this.value instanceof Annotation;
3116        }
3117
3118        /**
3119         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3120         */
3121        public Attachment getValueAttachment() throws FHIRException { 
3122          if (this.value == null)
3123            this.value = new Attachment();
3124          if (!(this.value instanceof Attachment))
3125            throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.value.getClass().getName()+" was encountered");
3126          return (Attachment) this.value;
3127        }
3128
3129        public boolean hasValueAttachment() { 
3130          return this != null && this.value instanceof Attachment;
3131        }
3132
3133        /**
3134         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3135         */
3136        public CodeableConcept getValueCodeableConcept() throws FHIRException { 
3137          if (this.value == null)
3138            this.value = new CodeableConcept();
3139          if (!(this.value instanceof CodeableConcept))
3140            throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.value.getClass().getName()+" was encountered");
3141          return (CodeableConcept) this.value;
3142        }
3143
3144        public boolean hasValueCodeableConcept() { 
3145          return this != null && this.value instanceof CodeableConcept;
3146        }
3147
3148        /**
3149         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3150         */
3151        public CodeableReference getValueCodeableReference() throws FHIRException { 
3152          if (this.value == null)
3153            this.value = new CodeableReference();
3154          if (!(this.value instanceof CodeableReference))
3155            throw new FHIRException("Type mismatch: the type CodeableReference was expected, but "+this.value.getClass().getName()+" was encountered");
3156          return (CodeableReference) this.value;
3157        }
3158
3159        public boolean hasValueCodeableReference() { 
3160          return this != null && this.value instanceof CodeableReference;
3161        }
3162
3163        /**
3164         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3165         */
3166        public Coding getValueCoding() throws FHIRException { 
3167          if (this.value == null)
3168            this.value = new Coding();
3169          if (!(this.value instanceof Coding))
3170            throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.value.getClass().getName()+" was encountered");
3171          return (Coding) this.value;
3172        }
3173
3174        public boolean hasValueCoding() { 
3175          return this != null && this.value instanceof Coding;
3176        }
3177
3178        /**
3179         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3180         */
3181        public ContactPoint getValueContactPoint() throws FHIRException { 
3182          if (this.value == null)
3183            this.value = new ContactPoint();
3184          if (!(this.value instanceof ContactPoint))
3185            throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.value.getClass().getName()+" was encountered");
3186          return (ContactPoint) this.value;
3187        }
3188
3189        public boolean hasValueContactPoint() { 
3190          return this != null && this.value instanceof ContactPoint;
3191        }
3192
3193        /**
3194         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3195         */
3196        public Count getValueCount() throws FHIRException { 
3197          if (this.value == null)
3198            this.value = new Count();
3199          if (!(this.value instanceof Count))
3200            throw new FHIRException("Type mismatch: the type Count was expected, but "+this.value.getClass().getName()+" was encountered");
3201          return (Count) this.value;
3202        }
3203
3204        public boolean hasValueCount() { 
3205          return this != null && this.value instanceof Count;
3206        }
3207
3208        /**
3209         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3210         */
3211        public Distance getValueDistance() throws FHIRException { 
3212          if (this.value == null)
3213            this.value = new Distance();
3214          if (!(this.value instanceof Distance))
3215            throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.value.getClass().getName()+" was encountered");
3216          return (Distance) this.value;
3217        }
3218
3219        public boolean hasValueDistance() { 
3220          return this != null && this.value instanceof Distance;
3221        }
3222
3223        /**
3224         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3225         */
3226        public Duration getValueDuration() throws FHIRException { 
3227          if (this.value == null)
3228            this.value = new Duration();
3229          if (!(this.value instanceof Duration))
3230            throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.value.getClass().getName()+" was encountered");
3231          return (Duration) this.value;
3232        }
3233
3234        public boolean hasValueDuration() { 
3235          return this != null && this.value instanceof Duration;
3236        }
3237
3238        /**
3239         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3240         */
3241        public HumanName getValueHumanName() throws FHIRException { 
3242          if (this.value == null)
3243            this.value = new HumanName();
3244          if (!(this.value instanceof HumanName))
3245            throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.value.getClass().getName()+" was encountered");
3246          return (HumanName) this.value;
3247        }
3248
3249        public boolean hasValueHumanName() { 
3250          return this != null && this.value instanceof HumanName;
3251        }
3252
3253        /**
3254         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3255         */
3256        public Identifier getValueIdentifier() throws FHIRException { 
3257          if (this.value == null)
3258            this.value = new Identifier();
3259          if (!(this.value instanceof Identifier))
3260            throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.value.getClass().getName()+" was encountered");
3261          return (Identifier) this.value;
3262        }
3263
3264        public boolean hasValueIdentifier() { 
3265          return this != null && this.value instanceof Identifier;
3266        }
3267
3268        /**
3269         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3270         */
3271        public Money getValueMoney() throws FHIRException { 
3272          if (this.value == null)
3273            this.value = new Money();
3274          if (!(this.value instanceof Money))
3275            throw new FHIRException("Type mismatch: the type Money was expected, but "+this.value.getClass().getName()+" was encountered");
3276          return (Money) this.value;
3277        }
3278
3279        public boolean hasValueMoney() { 
3280          return this != null && this.value instanceof Money;
3281        }
3282
3283        /**
3284         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3285         */
3286        public Period getValuePeriod() throws FHIRException { 
3287          if (this.value == null)
3288            this.value = new Period();
3289          if (!(this.value instanceof Period))
3290            throw new FHIRException("Type mismatch: the type Period was expected, but "+this.value.getClass().getName()+" was encountered");
3291          return (Period) this.value;
3292        }
3293
3294        public boolean hasValuePeriod() { 
3295          return this != null && this.value instanceof Period;
3296        }
3297
3298        /**
3299         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3300         */
3301        public Quantity getValueQuantity() throws FHIRException { 
3302          if (this.value == null)
3303            this.value = new Quantity();
3304          if (!(this.value instanceof Quantity))
3305            throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.value.getClass().getName()+" was encountered");
3306          return (Quantity) this.value;
3307        }
3308
3309        public boolean hasValueQuantity() { 
3310          return this != null && this.value instanceof Quantity;
3311        }
3312
3313        /**
3314         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3315         */
3316        public Range getValueRange() throws FHIRException { 
3317          if (this.value == null)
3318            this.value = new Range();
3319          if (!(this.value instanceof Range))
3320            throw new FHIRException("Type mismatch: the type Range was expected, but "+this.value.getClass().getName()+" was encountered");
3321          return (Range) this.value;
3322        }
3323
3324        public boolean hasValueRange() { 
3325          return this != null && this.value instanceof Range;
3326        }
3327
3328        /**
3329         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3330         */
3331        public Ratio getValueRatio() throws FHIRException { 
3332          if (this.value == null)
3333            this.value = new Ratio();
3334          if (!(this.value instanceof Ratio))
3335            throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.value.getClass().getName()+" was encountered");
3336          return (Ratio) this.value;
3337        }
3338
3339        public boolean hasValueRatio() { 
3340          return this != null && this.value instanceof Ratio;
3341        }
3342
3343        /**
3344         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3345         */
3346        public RatioRange getValueRatioRange() throws FHIRException { 
3347          if (this.value == null)
3348            this.value = new RatioRange();
3349          if (!(this.value instanceof RatioRange))
3350            throw new FHIRException("Type mismatch: the type RatioRange was expected, but "+this.value.getClass().getName()+" was encountered");
3351          return (RatioRange) this.value;
3352        }
3353
3354        public boolean hasValueRatioRange() { 
3355          return this != null && this.value instanceof RatioRange;
3356        }
3357
3358        /**
3359         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3360         */
3361        public Reference getValueReference() throws FHIRException { 
3362          if (this.value == null)
3363            this.value = new Reference();
3364          if (!(this.value instanceof Reference))
3365            throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.value.getClass().getName()+" was encountered");
3366          return (Reference) this.value;
3367        }
3368
3369        public boolean hasValueReference() { 
3370          return this != null && this.value instanceof Reference;
3371        }
3372
3373        /**
3374         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3375         */
3376        public SampledData getValueSampledData() throws FHIRException { 
3377          if (this.value == null)
3378            this.value = new SampledData();
3379          if (!(this.value instanceof SampledData))
3380            throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.value.getClass().getName()+" was encountered");
3381          return (SampledData) this.value;
3382        }
3383
3384        public boolean hasValueSampledData() { 
3385          return this != null && this.value instanceof SampledData;
3386        }
3387
3388        /**
3389         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3390         */
3391        public Signature getValueSignature() throws FHIRException { 
3392          if (this.value == null)
3393            this.value = new Signature();
3394          if (!(this.value instanceof Signature))
3395            throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.value.getClass().getName()+" was encountered");
3396          return (Signature) this.value;
3397        }
3398
3399        public boolean hasValueSignature() { 
3400          return this != null && this.value instanceof Signature;
3401        }
3402
3403        /**
3404         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3405         */
3406        public Timing getValueTiming() throws FHIRException { 
3407          if (this.value == null)
3408            this.value = new Timing();
3409          if (!(this.value instanceof Timing))
3410            throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.value.getClass().getName()+" was encountered");
3411          return (Timing) this.value;
3412        }
3413
3414        public boolean hasValueTiming() { 
3415          return this != null && this.value instanceof Timing;
3416        }
3417
3418        /**
3419         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3420         */
3421        public ContactDetail getValueContactDetail() throws FHIRException { 
3422          if (this.value == null)
3423            this.value = new ContactDetail();
3424          if (!(this.value instanceof ContactDetail))
3425            throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.value.getClass().getName()+" was encountered");
3426          return (ContactDetail) this.value;
3427        }
3428
3429        public boolean hasValueContactDetail() { 
3430          return this != null && this.value instanceof ContactDetail;
3431        }
3432
3433        /**
3434         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3435         */
3436        public DataRequirement getValueDataRequirement() throws FHIRException { 
3437          if (this.value == null)
3438            this.value = new DataRequirement();
3439          if (!(this.value instanceof DataRequirement))
3440            throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.value.getClass().getName()+" was encountered");
3441          return (DataRequirement) this.value;
3442        }
3443
3444        public boolean hasValueDataRequirement() { 
3445          return this != null && this.value instanceof DataRequirement;
3446        }
3447
3448        /**
3449         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3450         */
3451        public Expression getValueExpression() throws FHIRException { 
3452          if (this.value == null)
3453            this.value = new Expression();
3454          if (!(this.value instanceof Expression))
3455            throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.value.getClass().getName()+" was encountered");
3456          return (Expression) this.value;
3457        }
3458
3459        public boolean hasValueExpression() { 
3460          return this != null && this.value instanceof Expression;
3461        }
3462
3463        /**
3464         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3465         */
3466        public ParameterDefinition getValueParameterDefinition() throws FHIRException { 
3467          if (this.value == null)
3468            this.value = new ParameterDefinition();
3469          if (!(this.value instanceof ParameterDefinition))
3470            throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.value.getClass().getName()+" was encountered");
3471          return (ParameterDefinition) this.value;
3472        }
3473
3474        public boolean hasValueParameterDefinition() { 
3475          return this != null && this.value instanceof ParameterDefinition;
3476        }
3477
3478        /**
3479         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3480         */
3481        public RelatedArtifact getValueRelatedArtifact() throws FHIRException { 
3482          if (this.value == null)
3483            this.value = new RelatedArtifact();
3484          if (!(this.value instanceof RelatedArtifact))
3485            throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.value.getClass().getName()+" was encountered");
3486          return (RelatedArtifact) this.value;
3487        }
3488
3489        public boolean hasValueRelatedArtifact() { 
3490          return this != null && this.value instanceof RelatedArtifact;
3491        }
3492
3493        /**
3494         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3495         */
3496        public TriggerDefinition getValueTriggerDefinition() throws FHIRException { 
3497          if (this.value == null)
3498            this.value = new TriggerDefinition();
3499          if (!(this.value instanceof TriggerDefinition))
3500            throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.value.getClass().getName()+" was encountered");
3501          return (TriggerDefinition) this.value;
3502        }
3503
3504        public boolean hasValueTriggerDefinition() { 
3505          return this != null && this.value instanceof TriggerDefinition;
3506        }
3507
3508        /**
3509         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3510         */
3511        public UsageContext getValueUsageContext() throws FHIRException { 
3512          if (this.value == null)
3513            this.value = new UsageContext();
3514          if (!(this.value instanceof UsageContext))
3515            throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.value.getClass().getName()+" was encountered");
3516          return (UsageContext) this.value;
3517        }
3518
3519        public boolean hasValueUsageContext() { 
3520          return this != null && this.value instanceof UsageContext;
3521        }
3522
3523        /**
3524         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3525         */
3526        public Availability getValueAvailability() throws FHIRException { 
3527          if (this.value == null)
3528            this.value = new Availability();
3529          if (!(this.value instanceof Availability))
3530            throw new FHIRException("Type mismatch: the type Availability was expected, but "+this.value.getClass().getName()+" was encountered");
3531          return (Availability) this.value;
3532        }
3533
3534        public boolean hasValueAvailability() { 
3535          return this != null && this.value instanceof Availability;
3536        }
3537
3538        /**
3539         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3540         */
3541        public ExtendedContactDetail getValueExtendedContactDetail() throws FHIRException { 
3542          if (this.value == null)
3543            this.value = new ExtendedContactDetail();
3544          if (!(this.value instanceof ExtendedContactDetail))
3545            throw new FHIRException("Type mismatch: the type ExtendedContactDetail was expected, but "+this.value.getClass().getName()+" was encountered");
3546          return (ExtendedContactDetail) this.value;
3547        }
3548
3549        public boolean hasValueExtendedContactDetail() { 
3550          return this != null && this.value instanceof ExtendedContactDetail;
3551        }
3552
3553        /**
3554         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3555         */
3556        public Dosage getValueDosage() throws FHIRException { 
3557          if (this.value == null)
3558            this.value = new Dosage();
3559          if (!(this.value instanceof Dosage))
3560            throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.value.getClass().getName()+" was encountered");
3561          return (Dosage) this.value;
3562        }
3563
3564        public boolean hasValueDosage() { 
3565          return this != null && this.value instanceof Dosage;
3566        }
3567
3568        /**
3569         * @return {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3570         */
3571        public Meta getValueMeta() throws FHIRException { 
3572          if (this.value == null)
3573            this.value = new Meta();
3574          if (!(this.value instanceof Meta))
3575            throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.value.getClass().getName()+" was encountered");
3576          return (Meta) this.value;
3577        }
3578
3579        public boolean hasValueMeta() { 
3580          return this != null && this.value instanceof Meta;
3581        }
3582
3583        public boolean hasValue() { 
3584          return this.value != null && !this.value.isEmpty();
3585        }
3586
3587        /**
3588         * @param value {@link #value} (The actual value for the element, which must be one of the types allowed for this element.)
3589         */
3590        public ElementDefinitionExampleComponent setValue(DataType value) { 
3591          if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof CodeableReference || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof RatioRange || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Availability || value instanceof ExtendedContactDetail || value instanceof Dosage || value instanceof Meta))
3592            throw new FHIRException("Not the right type for ElementDefinition.example.value[x]: "+value.fhirType());
3593          this.value = value;
3594          return this;
3595        }
3596
3597        protected void listChildren(List<Property> children) {
3598          super.listChildren(children);
3599          children.add(new Property("label", "string", "Describes the purpose of this example among the set of examples.", 0, 1, label));
3600          children.add(new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|CodeableReference|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|RatioRange|Reference|SampledData|Signature|Timing|ContactDetail|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Availability|ExtendedContactDetail|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value));
3601        }
3602
3603        @Override
3604        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3605          switch (_hash) {
3606          case 102727412: /*label*/  return new Property("label", "string", "Describes the purpose of this example among the set of examples.", 0, 1, label);
3607          case -1410166417: /*value[x]*/  return new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|CodeableReference|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|RatioRange|Reference|SampledData|Signature|Timing|ContactDetail|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Availability|ExtendedContactDetail|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3608          case 111972721: /*value*/  return new Property("value[x]", "base64Binary|boolean|canonical|code|date|dateTime|decimal|id|instant|integer|integer64|markdown|oid|positiveInt|string|time|unsignedInt|uri|url|uuid|Address|Age|Annotation|Attachment|CodeableConcept|CodeableReference|Coding|ContactPoint|Count|Distance|Duration|HumanName|Identifier|Money|Period|Quantity|Range|Ratio|RatioRange|Reference|SampledData|Signature|Timing|ContactDetail|DataRequirement|Expression|ParameterDefinition|RelatedArtifact|TriggerDefinition|UsageContext|Availability|ExtendedContactDetail|Dosage|Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3609          case -1535024575: /*valueBase64Binary*/  return new Property("value[x]", "base64Binary", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3610          case 733421943: /*valueBoolean*/  return new Property("value[x]", "boolean", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3611          case -786218365: /*valueCanonical*/  return new Property("value[x]", "canonical", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3612          case -766209282: /*valueCode*/  return new Property("value[x]", "code", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3613          case -766192449: /*valueDate*/  return new Property("value[x]", "date", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3614          case 1047929900: /*valueDateTime*/  return new Property("value[x]", "dateTime", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3615          case -2083993440: /*valueDecimal*/  return new Property("value[x]", "decimal", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3616          case 231604844: /*valueId*/  return new Property("value[x]", "id", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3617          case -1668687056: /*valueInstant*/  return new Property("value[x]", "instant", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3618          case -1668204915: /*valueInteger*/  return new Property("value[x]", "integer", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3619          case -1122120181: /*valueInteger64*/  return new Property("value[x]", "integer64", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3620          case -497880704: /*valueMarkdown*/  return new Property("value[x]", "markdown", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3621          case -1410178407: /*valueOid*/  return new Property("value[x]", "oid", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3622          case -1249932027: /*valuePositiveInt*/  return new Property("value[x]", "positiveInt", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3623          case -1424603934: /*valueString*/  return new Property("value[x]", "string", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3624          case -765708322: /*valueTime*/  return new Property("value[x]", "time", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3625          case 26529417: /*valueUnsignedInt*/  return new Property("value[x]", "unsignedInt", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3626          case -1410172357: /*valueUri*/  return new Property("value[x]", "uri", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3627          case -1410172354: /*valueUrl*/  return new Property("value[x]", "url", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3628          case -765667124: /*valueUuid*/  return new Property("value[x]", "uuid", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3629          case -478981821: /*valueAddress*/  return new Property("value[x]", "Address", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3630          case -1410191922: /*valueAge*/  return new Property("value[x]", "Age", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3631          case -67108992: /*valueAnnotation*/  return new Property("value[x]", "Annotation", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3632          case -475566732: /*valueAttachment*/  return new Property("value[x]", "Attachment", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3633          case 924902896: /*valueCodeableConcept*/  return new Property("value[x]", "CodeableConcept", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3634          case -257955629: /*valueCodeableReference*/  return new Property("value[x]", "CodeableReference", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3635          case -1887705029: /*valueCoding*/  return new Property("value[x]", "Coding", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3636          case 944904545: /*valueContactPoint*/  return new Property("value[x]", "ContactPoint", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3637          case 2017332766: /*valueCount*/  return new Property("value[x]", "Count", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3638          case -456359802: /*valueDistance*/  return new Property("value[x]", "Distance", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3639          case 1558135333: /*valueDuration*/  return new Property("value[x]", "Duration", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3640          case -2026205465: /*valueHumanName*/  return new Property("value[x]", "HumanName", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3641          case -130498310: /*valueIdentifier*/  return new Property("value[x]", "Identifier", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3642          case 2026560975: /*valueMoney*/  return new Property("value[x]", "Money", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3643          case -1524344174: /*valuePeriod*/  return new Property("value[x]", "Period", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3644          case -2029823716: /*valueQuantity*/  return new Property("value[x]", "Quantity", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3645          case 2030761548: /*valueRange*/  return new Property("value[x]", "Range", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3646          case 2030767386: /*valueRatio*/  return new Property("value[x]", "Ratio", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3647          case -706454461: /*valueRatioRange*/  return new Property("value[x]", "RatioRange", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3648          case 1755241690: /*valueReference*/  return new Property("value[x]", "Reference", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3649          case -962229101: /*valueSampledData*/  return new Property("value[x]", "SampledData", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3650          case -540985785: /*valueSignature*/  return new Property("value[x]", "Signature", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3651          case -1406282469: /*valueTiming*/  return new Property("value[x]", "Timing", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3652          case -1125200224: /*valueContactDetail*/  return new Property("value[x]", "ContactDetail", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3653          case 1710554248: /*valueDataRequirement*/  return new Property("value[x]", "DataRequirement", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3654          case -307517719: /*valueExpression*/  return new Property("value[x]", "Expression", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3655          case 1387478187: /*valueParameterDefinition*/  return new Property("value[x]", "ParameterDefinition", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3656          case 1748214124: /*valueRelatedArtifact*/  return new Property("value[x]", "RelatedArtifact", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3657          case 976830394: /*valueTriggerDefinition*/  return new Property("value[x]", "TriggerDefinition", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3658          case 588000479: /*valueUsageContext*/  return new Property("value[x]", "UsageContext", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3659          case 1678530924: /*valueAvailability*/  return new Property("value[x]", "Availability", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3660          case -1567222041: /*valueExtendedContactDetail*/  return new Property("value[x]", "ExtendedContactDetail", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3661          case -1858636920: /*valueDosage*/  return new Property("value[x]", "Dosage", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3662          case -765920490: /*valueMeta*/  return new Property("value[x]", "Meta", "The actual value for the element, which must be one of the types allowed for this element.", 0, 1, value);
3663          default: return super.getNamedProperty(_hash, _name, _checkValid);
3664          }
3665
3666        }
3667
3668      @Override
3669      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3670        switch (hash) {
3671        case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType
3672        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType
3673        default: return super.getProperty(hash, name, checkValid);
3674        }
3675
3676      }
3677
3678      @Override
3679      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3680        switch (hash) {
3681        case 102727412: // label
3682          this.label = TypeConvertor.castToString(value); // StringType
3683          return value;
3684        case 111972721: // value
3685          this.value = TypeConvertor.castToType(value); // DataType
3686          return value;
3687        default: return super.setProperty(hash, name, value);
3688        }
3689
3690      }
3691
3692      @Override
3693      public Base setProperty(String name, Base value) throws FHIRException {
3694        if (name.equals("label")) {
3695          this.label = TypeConvertor.castToString(value); // StringType
3696        } else if (name.equals("value[x]")) {
3697          this.value = TypeConvertor.castToType(value); // DataType
3698        } else
3699          return super.setProperty(name, value);
3700        return value;
3701      }
3702
3703  @Override
3704  public void removeChild(String name, Base value) throws FHIRException {
3705        if (name.equals("label")) {
3706          this.label = null;
3707        } else if (name.equals("value[x]")) {
3708          this.value = null;
3709        } else
3710          super.removeChild(name, value);
3711        
3712      }
3713
3714      @Override
3715      public Base makeProperty(int hash, String name) throws FHIRException {
3716        switch (hash) {
3717        case 102727412:  return getLabelElement();
3718        case -1410166417:  return getValue();
3719        case 111972721:  return getValue();
3720        default: return super.makeProperty(hash, name);
3721        }
3722
3723      }
3724
3725      @Override
3726      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3727        switch (hash) {
3728        case 102727412: /*label*/ return new String[] {"string"};
3729        case 111972721: /*value*/ return new String[] {"base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "integer64", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "Address", "Age", "Annotation", "Attachment", "CodeableConcept", "CodeableReference", "Coding", "ContactPoint", "Count", "Distance", "Duration", "HumanName", "Identifier", "Money", "Period", "Quantity", "Range", "Ratio", "RatioRange", "Reference", "SampledData", "Signature", "Timing", "ContactDetail", "DataRequirement", "Expression", "ParameterDefinition", "RelatedArtifact", "TriggerDefinition", "UsageContext", "Availability", "ExtendedContactDetail", "Dosage", "Meta"};
3730        default: return super.getTypesForProperty(hash, name);
3731        }
3732
3733      }
3734
3735      @Override
3736      public Base addChild(String name) throws FHIRException {
3737        if (name.equals("label")) {
3738          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.example.label");
3739        }
3740        else if (name.equals("valueBase64Binary")) {
3741          this.value = new Base64BinaryType();
3742          return this.value;
3743        }
3744        else if (name.equals("valueBoolean")) {
3745          this.value = new BooleanType();
3746          return this.value;
3747        }
3748        else if (name.equals("valueCanonical")) {
3749          this.value = new CanonicalType();
3750          return this.value;
3751        }
3752        else if (name.equals("valueCode")) {
3753          this.value = new CodeType();
3754          return this.value;
3755        }
3756        else if (name.equals("valueDate")) {
3757          this.value = new DateType();
3758          return this.value;
3759        }
3760        else if (name.equals("valueDateTime")) {
3761          this.value = new DateTimeType();
3762          return this.value;
3763        }
3764        else if (name.equals("valueDecimal")) {
3765          this.value = new DecimalType();
3766          return this.value;
3767        }
3768        else if (name.equals("valueId")) {
3769          this.value = new IdType();
3770          return this.value;
3771        }
3772        else if (name.equals("valueInstant")) {
3773          this.value = new InstantType();
3774          return this.value;
3775        }
3776        else if (name.equals("valueInteger")) {
3777          this.value = new IntegerType();
3778          return this.value;
3779        }
3780        else if (name.equals("valueInteger64")) {
3781          this.value = new Integer64Type();
3782          return this.value;
3783        }
3784        else if (name.equals("valueMarkdown")) {
3785          this.value = new MarkdownType();
3786          return this.value;
3787        }
3788        else if (name.equals("valueOid")) {
3789          this.value = new OidType();
3790          return this.value;
3791        }
3792        else if (name.equals("valuePositiveInt")) {
3793          this.value = new PositiveIntType();
3794          return this.value;
3795        }
3796        else if (name.equals("valueString")) {
3797          this.value = new StringType();
3798          return this.value;
3799        }
3800        else if (name.equals("valueTime")) {
3801          this.value = new TimeType();
3802          return this.value;
3803        }
3804        else if (name.equals("valueUnsignedInt")) {
3805          this.value = new UnsignedIntType();
3806          return this.value;
3807        }
3808        else if (name.equals("valueUri")) {
3809          this.value = new UriType();
3810          return this.value;
3811        }
3812        else if (name.equals("valueUrl")) {
3813          this.value = new UrlType();
3814          return this.value;
3815        }
3816        else if (name.equals("valueUuid")) {
3817          this.value = new UuidType();
3818          return this.value;
3819        }
3820        else if (name.equals("valueAddress")) {
3821          this.value = new Address();
3822          return this.value;
3823        }
3824        else if (name.equals("valueAge")) {
3825          this.value = new Age();
3826          return this.value;
3827        }
3828        else if (name.equals("valueAnnotation")) {
3829          this.value = new Annotation();
3830          return this.value;
3831        }
3832        else if (name.equals("valueAttachment")) {
3833          this.value = new Attachment();
3834          return this.value;
3835        }
3836        else if (name.equals("valueCodeableConcept")) {
3837          this.value = new CodeableConcept();
3838          return this.value;
3839        }
3840        else if (name.equals("valueCodeableReference")) {
3841          this.value = new CodeableReference();
3842          return this.value;
3843        }
3844        else if (name.equals("valueCoding")) {
3845          this.value = new Coding();
3846          return this.value;
3847        }
3848        else if (name.equals("valueContactPoint")) {
3849          this.value = new ContactPoint();
3850          return this.value;
3851        }
3852        else if (name.equals("valueCount")) {
3853          this.value = new Count();
3854          return this.value;
3855        }
3856        else if (name.equals("valueDistance")) {
3857          this.value = new Distance();
3858          return this.value;
3859        }
3860        else if (name.equals("valueDuration")) {
3861          this.value = new Duration();
3862          return this.value;
3863        }
3864        else if (name.equals("valueHumanName")) {
3865          this.value = new HumanName();
3866          return this.value;
3867        }
3868        else if (name.equals("valueIdentifier")) {
3869          this.value = new Identifier();
3870          return this.value;
3871        }
3872        else if (name.equals("valueMoney")) {
3873          this.value = new Money();
3874          return this.value;
3875        }
3876        else if (name.equals("valuePeriod")) {
3877          this.value = new Period();
3878          return this.value;
3879        }
3880        else if (name.equals("valueQuantity")) {
3881          this.value = new Quantity();
3882          return this.value;
3883        }
3884        else if (name.equals("valueRange")) {
3885          this.value = new Range();
3886          return this.value;
3887        }
3888        else if (name.equals("valueRatio")) {
3889          this.value = new Ratio();
3890          return this.value;
3891        }
3892        else if (name.equals("valueRatioRange")) {
3893          this.value = new RatioRange();
3894          return this.value;
3895        }
3896        else if (name.equals("valueReference")) {
3897          this.value = new Reference();
3898          return this.value;
3899        }
3900        else if (name.equals("valueSampledData")) {
3901          this.value = new SampledData();
3902          return this.value;
3903        }
3904        else if (name.equals("valueSignature")) {
3905          this.value = new Signature();
3906          return this.value;
3907        }
3908        else if (name.equals("valueTiming")) {
3909          this.value = new Timing();
3910          return this.value;
3911        }
3912        else if (name.equals("valueContactDetail")) {
3913          this.value = new ContactDetail();
3914          return this.value;
3915        }
3916        else if (name.equals("valueDataRequirement")) {
3917          this.value = new DataRequirement();
3918          return this.value;
3919        }
3920        else if (name.equals("valueExpression")) {
3921          this.value = new Expression();
3922          return this.value;
3923        }
3924        else if (name.equals("valueParameterDefinition")) {
3925          this.value = new ParameterDefinition();
3926          return this.value;
3927        }
3928        else if (name.equals("valueRelatedArtifact")) {
3929          this.value = new RelatedArtifact();
3930          return this.value;
3931        }
3932        else if (name.equals("valueTriggerDefinition")) {
3933          this.value = new TriggerDefinition();
3934          return this.value;
3935        }
3936        else if (name.equals("valueUsageContext")) {
3937          this.value = new UsageContext();
3938          return this.value;
3939        }
3940        else if (name.equals("valueAvailability")) {
3941          this.value = new Availability();
3942          return this.value;
3943        }
3944        else if (name.equals("valueExtendedContactDetail")) {
3945          this.value = new ExtendedContactDetail();
3946          return this.value;
3947        }
3948        else if (name.equals("valueDosage")) {
3949          this.value = new Dosage();
3950          return this.value;
3951        }
3952        else if (name.equals("valueMeta")) {
3953          this.value = new Meta();
3954          return this.value;
3955        }
3956        else
3957          return super.addChild(name);
3958      }
3959
3960      public ElementDefinitionExampleComponent copy() {
3961        ElementDefinitionExampleComponent dst = new ElementDefinitionExampleComponent();
3962        copyValues(dst);
3963        return dst;
3964      }
3965
3966      public void copyValues(ElementDefinitionExampleComponent dst) {
3967        super.copyValues(dst);
3968        dst.label = label == null ? null : label.copy();
3969        dst.value = value == null ? null : value.copy();
3970      }
3971
3972      @Override
3973      public boolean equalsDeep(Base other_) {
3974        if (!super.equalsDeep(other_))
3975          return false;
3976        if (!(other_ instanceof ElementDefinitionExampleComponent))
3977          return false;
3978        ElementDefinitionExampleComponent o = (ElementDefinitionExampleComponent) other_;
3979        return compareDeep(label, o.label, true) && compareDeep(value, o.value, true);
3980      }
3981
3982      @Override
3983      public boolean equalsShallow(Base other_) {
3984        if (!super.equalsShallow(other_))
3985          return false;
3986        if (!(other_ instanceof ElementDefinitionExampleComponent))
3987          return false;
3988        ElementDefinitionExampleComponent o = (ElementDefinitionExampleComponent) other_;
3989        return compareValues(label, o.label, true);
3990      }
3991
3992      public boolean isEmpty() {
3993        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, value);
3994      }
3995
3996  public String fhirType() {
3997    return "ElementDefinition.example";
3998
3999  }
4000
4001  }
4002
4003    @Block()
4004    public static class ElementDefinitionConstraintComponent extends Element implements IBaseDatatypeElement {
4005        /**
4006         * Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.
4007         */
4008        @Child(name = "key", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
4009        @Description(shortDefinition="Target of 'condition' reference above", formalDefinition="Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality." )
4010        protected IdType key;
4011
4012        /**
4013         * Description of why this constraint is necessary or appropriate.
4014         */
4015        @Child(name = "requirements", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=true)
4016        @Description(shortDefinition="Why this constraint is necessary or appropriate", formalDefinition="Description of why this constraint is necessary or appropriate." )
4017        protected MarkdownType requirements;
4018
4019        /**
4020         * Identifies the impact constraint violation has on the conformance of the instance.
4021         */
4022        @Child(name = "severity", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
4023        @Description(shortDefinition="error | warning", formalDefinition="Identifies the impact constraint violation has on the conformance of the instance." )
4024        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/constraint-severity")
4025        protected Enumeration<ConstraintSeverity> severity;
4026
4027        /**
4028         * If true, indicates that the warning or best practice guideline should be suppressed.
4029         */
4030        @Child(name = "suppress", type = {BooleanType.class}, order=4, min=0, max=1, modifier=false, summary=true)
4031        @Description(shortDefinition="Suppress warning or hint in profile", formalDefinition="If true, indicates that the warning or best practice guideline should be suppressed." )
4032        protected BooleanType suppress;
4033
4034        /**
4035         * Text that can be used to describe the constraint in messages identifying that the constraint has been violated.
4036         */
4037        @Child(name = "human", type = {StringType.class}, order=5, min=1, max=1, modifier=false, summary=true)
4038        @Description(shortDefinition="Human description of constraint", formalDefinition="Text that can be used to describe the constraint in messages identifying that the constraint has been violated." )
4039        protected StringType human;
4040
4041        /**
4042         * A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.
4043         */
4044        @Child(name = "expression", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=true)
4045        @Description(shortDefinition="FHIRPath expression of constraint", formalDefinition="A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met." )
4046        protected StringType expression;
4047
4048        /**
4049         * A reference to the original source of the constraint, for traceability purposes.
4050         */
4051        @Child(name = "source", type = {CanonicalType.class}, order=7, min=0, max=1, modifier=false, summary=true)
4052        @Description(shortDefinition="Reference to original source of constraint", formalDefinition="A reference to the original source of the constraint, for traceability purposes." )
4053        protected CanonicalType source;
4054
4055        private static final long serialVersionUID = 1642607838L;
4056
4057    /**
4058     * Constructor
4059     */
4060      public ElementDefinitionConstraintComponent() {
4061        super();
4062      }
4063
4064    /**
4065     * Constructor
4066     */
4067      public ElementDefinitionConstraintComponent(String key, ConstraintSeverity severity, String human) {
4068        super();
4069        this.setKey(key);
4070        this.setSeverity(severity);
4071        this.setHuman(human);
4072      }
4073
4074        /**
4075         * @return {@link #key} (Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.). This is the underlying object with id, value and extensions. The accessor "getKey" gives direct access to the value
4076         */
4077        public IdType getKeyElement() { 
4078          if (this.key == null)
4079            if (Configuration.errorOnAutoCreate())
4080              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.key");
4081            else if (Configuration.doAutoCreate())
4082              this.key = new IdType(); // bb
4083          return this.key;
4084        }
4085
4086        public boolean hasKeyElement() { 
4087          return this.key != null && !this.key.isEmpty();
4088        }
4089
4090        public boolean hasKey() { 
4091          return this.key != null && !this.key.isEmpty();
4092        }
4093
4094        /**
4095         * @param value {@link #key} (Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.). This is the underlying object with id, value and extensions. The accessor "getKey" gives direct access to the value
4096         */
4097        public ElementDefinitionConstraintComponent setKeyElement(IdType value) { 
4098          this.key = value;
4099          return this;
4100        }
4101
4102        /**
4103         * @return Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.
4104         */
4105        public String getKey() { 
4106          return this.key == null ? null : this.key.getValue();
4107        }
4108
4109        /**
4110         * @param value Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.
4111         */
4112        public ElementDefinitionConstraintComponent setKey(String value) { 
4113            if (this.key == null)
4114              this.key = new IdType();
4115            this.key.setValue(value);
4116          return this;
4117        }
4118
4119        /**
4120         * @return {@link #requirements} (Description of why this constraint is necessary or appropriate.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
4121         */
4122        public MarkdownType getRequirementsElement() { 
4123          if (this.requirements == null)
4124            if (Configuration.errorOnAutoCreate())
4125              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.requirements");
4126            else if (Configuration.doAutoCreate())
4127              this.requirements = new MarkdownType(); // bb
4128          return this.requirements;
4129        }
4130
4131        public boolean hasRequirementsElement() { 
4132          return this.requirements != null && !this.requirements.isEmpty();
4133        }
4134
4135        public boolean hasRequirements() { 
4136          return this.requirements != null && !this.requirements.isEmpty();
4137        }
4138
4139        /**
4140         * @param value {@link #requirements} (Description of why this constraint is necessary or appropriate.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
4141         */
4142        public ElementDefinitionConstraintComponent setRequirementsElement(MarkdownType value) { 
4143          this.requirements = value;
4144          return this;
4145        }
4146
4147        /**
4148         * @return Description of why this constraint is necessary or appropriate.
4149         */
4150        public String getRequirements() { 
4151          return this.requirements == null ? null : this.requirements.getValue();
4152        }
4153
4154        /**
4155         * @param value Description of why this constraint is necessary or appropriate.
4156         */
4157        public ElementDefinitionConstraintComponent setRequirements(String value) { 
4158          if (Utilities.noString(value))
4159            this.requirements = null;
4160          else {
4161            if (this.requirements == null)
4162              this.requirements = new MarkdownType();
4163            this.requirements.setValue(value);
4164          }
4165          return this;
4166        }
4167
4168        /**
4169         * @return {@link #severity} (Identifies the impact constraint violation has on the conformance of the instance.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value
4170         */
4171        public Enumeration<ConstraintSeverity> getSeverityElement() { 
4172          if (this.severity == null)
4173            if (Configuration.errorOnAutoCreate())
4174              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.severity");
4175            else if (Configuration.doAutoCreate())
4176              this.severity = new Enumeration<ConstraintSeverity>(new ConstraintSeverityEnumFactory()); // bb
4177          return this.severity;
4178        }
4179
4180        public boolean hasSeverityElement() { 
4181          return this.severity != null && !this.severity.isEmpty();
4182        }
4183
4184        public boolean hasSeverity() { 
4185          return this.severity != null && !this.severity.isEmpty();
4186        }
4187
4188        /**
4189         * @param value {@link #severity} (Identifies the impact constraint violation has on the conformance of the instance.). This is the underlying object with id, value and extensions. The accessor "getSeverity" gives direct access to the value
4190         */
4191        public ElementDefinitionConstraintComponent setSeverityElement(Enumeration<ConstraintSeverity> value) { 
4192          this.severity = value;
4193          return this;
4194        }
4195
4196        /**
4197         * @return Identifies the impact constraint violation has on the conformance of the instance.
4198         */
4199        public ConstraintSeverity getSeverity() { 
4200          return this.severity == null ? null : this.severity.getValue();
4201        }
4202
4203        /**
4204         * @param value Identifies the impact constraint violation has on the conformance of the instance.
4205         */
4206        public ElementDefinitionConstraintComponent setSeverity(ConstraintSeverity value) { 
4207            if (this.severity == null)
4208              this.severity = new Enumeration<ConstraintSeverity>(new ConstraintSeverityEnumFactory());
4209            this.severity.setValue(value);
4210          return this;
4211        }
4212
4213        /**
4214         * @return {@link #suppress} (If true, indicates that the warning or best practice guideline should be suppressed.). This is the underlying object with id, value and extensions. The accessor "getSuppress" gives direct access to the value
4215         */
4216        public BooleanType getSuppressElement() { 
4217          if (this.suppress == null)
4218            if (Configuration.errorOnAutoCreate())
4219              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.suppress");
4220            else if (Configuration.doAutoCreate())
4221              this.suppress = new BooleanType(); // bb
4222          return this.suppress;
4223        }
4224
4225        public boolean hasSuppressElement() { 
4226          return this.suppress != null && !this.suppress.isEmpty();
4227        }
4228
4229        public boolean hasSuppress() { 
4230          return this.suppress != null && !this.suppress.isEmpty();
4231        }
4232
4233        /**
4234         * @param value {@link #suppress} (If true, indicates that the warning or best practice guideline should be suppressed.). This is the underlying object with id, value and extensions. The accessor "getSuppress" gives direct access to the value
4235         */
4236        public ElementDefinitionConstraintComponent setSuppressElement(BooleanType value) { 
4237          this.suppress = value;
4238          return this;
4239        }
4240
4241        /**
4242         * @return If true, indicates that the warning or best practice guideline should be suppressed.
4243         */
4244        public boolean getSuppress() { 
4245          return this.suppress == null || this.suppress.isEmpty() ? false : this.suppress.getValue();
4246        }
4247
4248        /**
4249         * @param value If true, indicates that the warning or best practice guideline should be suppressed.
4250         */
4251        public ElementDefinitionConstraintComponent setSuppress(boolean value) { 
4252            if (this.suppress == null)
4253              this.suppress = new BooleanType();
4254            this.suppress.setValue(value);
4255          return this;
4256        }
4257
4258        /**
4259         * @return {@link #human} (Text that can be used to describe the constraint in messages identifying that the constraint has been violated.). This is the underlying object with id, value and extensions. The accessor "getHuman" gives direct access to the value
4260         */
4261        public StringType getHumanElement() { 
4262          if (this.human == null)
4263            if (Configuration.errorOnAutoCreate())
4264              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.human");
4265            else if (Configuration.doAutoCreate())
4266              this.human = new StringType(); // bb
4267          return this.human;
4268        }
4269
4270        public boolean hasHumanElement() { 
4271          return this.human != null && !this.human.isEmpty();
4272        }
4273
4274        public boolean hasHuman() { 
4275          return this.human != null && !this.human.isEmpty();
4276        }
4277
4278        /**
4279         * @param value {@link #human} (Text that can be used to describe the constraint in messages identifying that the constraint has been violated.). This is the underlying object with id, value and extensions. The accessor "getHuman" gives direct access to the value
4280         */
4281        public ElementDefinitionConstraintComponent setHumanElement(StringType value) { 
4282          this.human = value;
4283          return this;
4284        }
4285
4286        /**
4287         * @return Text that can be used to describe the constraint in messages identifying that the constraint has been violated.
4288         */
4289        public String getHuman() { 
4290          return this.human == null ? null : this.human.getValue();
4291        }
4292
4293        /**
4294         * @param value Text that can be used to describe the constraint in messages identifying that the constraint has been violated.
4295         */
4296        public ElementDefinitionConstraintComponent setHuman(String value) { 
4297            if (this.human == null)
4298              this.human = new StringType();
4299            this.human.setValue(value);
4300          return this;
4301        }
4302
4303        /**
4304         * @return {@link #expression} (A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
4305         */
4306        public StringType getExpressionElement() { 
4307          if (this.expression == null)
4308            if (Configuration.errorOnAutoCreate())
4309              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.expression");
4310            else if (Configuration.doAutoCreate())
4311              this.expression = new StringType(); // bb
4312          return this.expression;
4313        }
4314
4315        public boolean hasExpressionElement() { 
4316          return this.expression != null && !this.expression.isEmpty();
4317        }
4318
4319        public boolean hasExpression() { 
4320          return this.expression != null && !this.expression.isEmpty();
4321        }
4322
4323        /**
4324         * @param value {@link #expression} (A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
4325         */
4326        public ElementDefinitionConstraintComponent setExpressionElement(StringType value) { 
4327          this.expression = value;
4328          return this;
4329        }
4330
4331        /**
4332         * @return A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.
4333         */
4334        public String getExpression() { 
4335          return this.expression == null ? null : this.expression.getValue();
4336        }
4337
4338        /**
4339         * @param value A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.
4340         */
4341        public ElementDefinitionConstraintComponent setExpression(String value) { 
4342          if (Utilities.noString(value))
4343            this.expression = null;
4344          else {
4345            if (this.expression == null)
4346              this.expression = new StringType();
4347            this.expression.setValue(value);
4348          }
4349          return this;
4350        }
4351
4352        /**
4353         * @return {@link #source} (A reference to the original source of the constraint, for traceability purposes.). This is the underlying object with id, value and extensions. The accessor "getSource" gives direct access to the value
4354         */
4355        public CanonicalType getSourceElement() { 
4356          if (this.source == null)
4357            if (Configuration.errorOnAutoCreate())
4358              throw new Error("Attempt to auto-create ElementDefinitionConstraintComponent.source");
4359            else if (Configuration.doAutoCreate())
4360              this.source = new CanonicalType(); // bb
4361          return this.source;
4362        }
4363
4364        public boolean hasSourceElement() { 
4365          return this.source != null && !this.source.isEmpty();
4366        }
4367
4368        public boolean hasSource() { 
4369          return this.source != null && !this.source.isEmpty();
4370        }
4371
4372        /**
4373         * @param value {@link #source} (A reference to the original source of the constraint, for traceability purposes.). This is the underlying object with id, value and extensions. The accessor "getSource" gives direct access to the value
4374         */
4375        public ElementDefinitionConstraintComponent setSourceElement(CanonicalType value) { 
4376          this.source = value;
4377          return this;
4378        }
4379
4380        /**
4381         * @return A reference to the original source of the constraint, for traceability purposes.
4382         */
4383        public String getSource() { 
4384          return this.source == null ? null : this.source.getValue();
4385        }
4386
4387        /**
4388         * @param value A reference to the original source of the constraint, for traceability purposes.
4389         */
4390        public ElementDefinitionConstraintComponent setSource(String value) { 
4391          if (Utilities.noString(value))
4392            this.source = null;
4393          else {
4394            if (this.source == null)
4395              this.source = new CanonicalType();
4396            this.source.setValue(value);
4397          }
4398          return this;
4399        }
4400
4401        protected void listChildren(List<Property> children) {
4402          super.listChildren(children);
4403          children.add(new Property("key", "id", "Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.", 0, 1, key));
4404          children.add(new Property("requirements", "markdown", "Description of why this constraint is necessary or appropriate.", 0, 1, requirements));
4405          children.add(new Property("severity", "code", "Identifies the impact constraint violation has on the conformance of the instance.", 0, 1, severity));
4406          children.add(new Property("suppress", "boolean", "If true, indicates that the warning or best practice guideline should be suppressed.", 0, 1, suppress));
4407          children.add(new Property("human", "string", "Text that can be used to describe the constraint in messages identifying that the constraint has been violated.", 0, 1, human));
4408          children.add(new Property("expression", "string", "A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.", 0, 1, expression));
4409          children.add(new Property("source", "canonical(StructureDefinition)", "A reference to the original source of the constraint, for traceability purposes.", 0, 1, source));
4410        }
4411
4412        @Override
4413        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4414          switch (_hash) {
4415          case 106079: /*key*/  return new Property("key", "id", "Allows identification of which elements have their cardinalities impacted by the constraint.  Will not be referenced for constraints that do not affect cardinality.", 0, 1, key);
4416          case -1619874672: /*requirements*/  return new Property("requirements", "markdown", "Description of why this constraint is necessary or appropriate.", 0, 1, requirements);
4417          case 1478300413: /*severity*/  return new Property("severity", "code", "Identifies the impact constraint violation has on the conformance of the instance.", 0, 1, severity);
4418          case -1663129931: /*suppress*/  return new Property("suppress", "boolean", "If true, indicates that the warning or best practice guideline should be suppressed.", 0, 1, suppress);
4419          case 99639597: /*human*/  return new Property("human", "string", "Text that can be used to describe the constraint in messages identifying that the constraint has been violated.", 0, 1, human);
4420          case -1795452264: /*expression*/  return new Property("expression", "string", "A [FHIRPath](fhirpath.html) expression of constraint that can be executed to see if this constraint is met.", 0, 1, expression);
4421          case -896505829: /*source*/  return new Property("source", "canonical(StructureDefinition)", "A reference to the original source of the constraint, for traceability purposes.", 0, 1, source);
4422          default: return super.getNamedProperty(_hash, _name, _checkValid);
4423          }
4424
4425        }
4426
4427      @Override
4428      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4429        switch (hash) {
4430        case 106079: /*key*/ return this.key == null ? new Base[0] : new Base[] {this.key}; // IdType
4431        case -1619874672: /*requirements*/ return this.requirements == null ? new Base[0] : new Base[] {this.requirements}; // MarkdownType
4432        case 1478300413: /*severity*/ return this.severity == null ? new Base[0] : new Base[] {this.severity}; // Enumeration<ConstraintSeverity>
4433        case -1663129931: /*suppress*/ return this.suppress == null ? new Base[0] : new Base[] {this.suppress}; // BooleanType
4434        case 99639597: /*human*/ return this.human == null ? new Base[0] : new Base[] {this.human}; // StringType
4435        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
4436        case -896505829: /*source*/ return this.source == null ? new Base[0] : new Base[] {this.source}; // CanonicalType
4437        default: return super.getProperty(hash, name, checkValid);
4438        }
4439
4440      }
4441
4442      @Override
4443      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4444        switch (hash) {
4445        case 106079: // key
4446          this.key = TypeConvertor.castToId(value); // IdType
4447          return value;
4448        case -1619874672: // requirements
4449          this.requirements = TypeConvertor.castToMarkdown(value); // MarkdownType
4450          return value;
4451        case 1478300413: // severity
4452          value = new ConstraintSeverityEnumFactory().fromType(TypeConvertor.castToCode(value));
4453          this.severity = (Enumeration) value; // Enumeration<ConstraintSeverity>
4454          return value;
4455        case -1663129931: // suppress
4456          this.suppress = TypeConvertor.castToBoolean(value); // BooleanType
4457          return value;
4458        case 99639597: // human
4459          this.human = TypeConvertor.castToString(value); // StringType
4460          return value;
4461        case -1795452264: // expression
4462          this.expression = TypeConvertor.castToString(value); // StringType
4463          return value;
4464        case -896505829: // source
4465          this.source = TypeConvertor.castToCanonical(value); // CanonicalType
4466          return value;
4467        default: return super.setProperty(hash, name, value);
4468        }
4469
4470      }
4471
4472      @Override
4473      public Base setProperty(String name, Base value) throws FHIRException {
4474        if (name.equals("key")) {
4475          this.key = TypeConvertor.castToId(value); // IdType
4476        } else if (name.equals("requirements")) {
4477          this.requirements = TypeConvertor.castToMarkdown(value); // MarkdownType
4478        } else if (name.equals("severity")) {
4479          value = new ConstraintSeverityEnumFactory().fromType(TypeConvertor.castToCode(value));
4480          this.severity = (Enumeration) value; // Enumeration<ConstraintSeverity>
4481        } else if (name.equals("suppress")) {
4482          this.suppress = TypeConvertor.castToBoolean(value); // BooleanType
4483        } else if (name.equals("human")) {
4484          this.human = TypeConvertor.castToString(value); // StringType
4485        } else if (name.equals("expression")) {
4486          this.expression = TypeConvertor.castToString(value); // StringType
4487        } else if (name.equals("source")) {
4488          this.source = TypeConvertor.castToCanonical(value); // CanonicalType
4489        } else
4490          return super.setProperty(name, value);
4491        return value;
4492      }
4493
4494  @Override
4495  public void removeChild(String name, Base value) throws FHIRException {
4496        if (name.equals("key")) {
4497          this.key = null;
4498        } else if (name.equals("requirements")) {
4499          this.requirements = null;
4500        } else if (name.equals("severity")) {
4501          value = new ConstraintSeverityEnumFactory().fromType(TypeConvertor.castToCode(value));
4502          this.severity = (Enumeration) value; // Enumeration<ConstraintSeverity>
4503        } else if (name.equals("suppress")) {
4504          this.suppress = null;
4505        } else if (name.equals("human")) {
4506          this.human = null;
4507        } else if (name.equals("expression")) {
4508          this.expression = null;
4509        } else if (name.equals("source")) {
4510          this.source = null;
4511        } else
4512          super.removeChild(name, value);
4513        
4514      }
4515
4516      @Override
4517      public Base makeProperty(int hash, String name) throws FHIRException {
4518        switch (hash) {
4519        case 106079:  return getKeyElement();
4520        case -1619874672:  return getRequirementsElement();
4521        case 1478300413:  return getSeverityElement();
4522        case -1663129931:  return getSuppressElement();
4523        case 99639597:  return getHumanElement();
4524        case -1795452264:  return getExpressionElement();
4525        case -896505829:  return getSourceElement();
4526        default: return super.makeProperty(hash, name);
4527        }
4528
4529      }
4530
4531      @Override
4532      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4533        switch (hash) {
4534        case 106079: /*key*/ return new String[] {"id"};
4535        case -1619874672: /*requirements*/ return new String[] {"markdown"};
4536        case 1478300413: /*severity*/ return new String[] {"code"};
4537        case -1663129931: /*suppress*/ return new String[] {"boolean"};
4538        case 99639597: /*human*/ return new String[] {"string"};
4539        case -1795452264: /*expression*/ return new String[] {"string"};
4540        case -896505829: /*source*/ return new String[] {"canonical"};
4541        default: return super.getTypesForProperty(hash, name);
4542        }
4543
4544      }
4545
4546      @Override
4547      public Base addChild(String name) throws FHIRException {
4548        if (name.equals("key")) {
4549          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.key");
4550        }
4551        else if (name.equals("requirements")) {
4552          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.requirements");
4553        }
4554        else if (name.equals("severity")) {
4555          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.severity");
4556        }
4557        else if (name.equals("suppress")) {
4558          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.suppress");
4559        }
4560        else if (name.equals("human")) {
4561          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.human");
4562        }
4563        else if (name.equals("expression")) {
4564          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.expression");
4565        }
4566        else if (name.equals("source")) {
4567          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.constraint.source");
4568        }
4569        else
4570          return super.addChild(name);
4571      }
4572
4573      public ElementDefinitionConstraintComponent copy() {
4574        ElementDefinitionConstraintComponent dst = new ElementDefinitionConstraintComponent();
4575        copyValues(dst);
4576        return dst;
4577      }
4578
4579      public void copyValues(ElementDefinitionConstraintComponent dst) {
4580        super.copyValues(dst);
4581        dst.key = key == null ? null : key.copy();
4582        dst.requirements = requirements == null ? null : requirements.copy();
4583        dst.severity = severity == null ? null : severity.copy();
4584        dst.suppress = suppress == null ? null : suppress.copy();
4585        dst.human = human == null ? null : human.copy();
4586        dst.expression = expression == null ? null : expression.copy();
4587        dst.source = source == null ? null : source.copy();
4588      }
4589
4590      @Override
4591      public boolean equalsDeep(Base other_) {
4592        if (!super.equalsDeep(other_))
4593          return false;
4594        if (!(other_ instanceof ElementDefinitionConstraintComponent))
4595          return false;
4596        ElementDefinitionConstraintComponent o = (ElementDefinitionConstraintComponent) other_;
4597        return compareDeep(key, o.key, true) && compareDeep(requirements, o.requirements, true) && compareDeep(severity, o.severity, true)
4598           && compareDeep(suppress, o.suppress, true) && compareDeep(human, o.human, true) && compareDeep(expression, o.expression, true)
4599           && compareDeep(source, o.source, true);
4600      }
4601
4602      @Override
4603      public boolean equalsShallow(Base other_) {
4604        if (!super.equalsShallow(other_))
4605          return false;
4606        if (!(other_ instanceof ElementDefinitionConstraintComponent))
4607          return false;
4608        ElementDefinitionConstraintComponent o = (ElementDefinitionConstraintComponent) other_;
4609        return compareValues(key, o.key, true) && compareValues(requirements, o.requirements, true) && compareValues(severity, o.severity, true)
4610           && compareValues(suppress, o.suppress, true) && compareValues(human, o.human, true) && compareValues(expression, o.expression, true)
4611           && compareValues(source, o.source, true);
4612      }
4613
4614      public boolean isEmpty() {
4615        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(key, requirements, severity
4616          , suppress, human, expression, source);
4617      }
4618
4619  public String fhirType() {
4620    return "ElementDefinition.constraint";
4621
4622  }
4623
4624  @Override
4625  public String toString() {
4626    return key + ":" + expression + (severity == null ? "("+severity.asStringValue()+")" : "");
4627  }
4628
4629  }
4630
4631    @Block()
4632    public static class ElementDefinitionBindingComponent extends Element implements IBaseDatatypeElement {
4633        /**
4634         * Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.
4635         */
4636        @Child(name = "strength", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
4637        @Description(shortDefinition="required | extensible | preferred | example", formalDefinition="Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances." )
4638        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/binding-strength")
4639        protected Enumeration<BindingStrength> strength;
4640
4641        /**
4642         * Describes the intended use of this particular set of codes.
4643         */
4644        @Child(name = "description", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=true)
4645        @Description(shortDefinition="Intended use of codes in the bound value set", formalDefinition="Describes the intended use of this particular set of codes." )
4646        protected MarkdownType description;
4647
4648        /**
4649         * Refers to the value set that identifies the set of codes the binding refers to.
4650         */
4651        @Child(name = "valueSet", type = {CanonicalType.class}, order=3, min=0, max=1, modifier=false, summary=true)
4652        @Description(shortDefinition="Source of value set", formalDefinition="Refers to the value set that identifies the set of codes the binding refers to." )
4653        protected CanonicalType valueSet;
4654
4655        /**
4656         * Additional bindings that help applications implementing this element. Additional bindings do not replace the main binding but provide more information and/or context.
4657         */
4658        @Child(name = "additional", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4659        @Description(shortDefinition="Additional Bindings - more rules about the binding", formalDefinition="Additional bindings that help applications implementing this element. Additional bindings do not replace the main binding but provide more information and/or context." )
4660        protected List<ElementDefinitionBindingAdditionalComponent> additional;
4661
4662        private static final long serialVersionUID = 16276611L;
4663
4664    /**
4665     * Constructor
4666     */
4667      public ElementDefinitionBindingComponent() {
4668        super();
4669      }
4670
4671    /**
4672     * Constructor
4673     */
4674      public ElementDefinitionBindingComponent(BindingStrength strength) {
4675        super();
4676        this.setStrength(strength);
4677      }
4678
4679        /**
4680         * @return {@link #strength} (Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.). This is the underlying object with id, value and extensions. The accessor "getStrength" gives direct access to the value
4681         */
4682        public Enumeration<BindingStrength> getStrengthElement() { 
4683          if (this.strength == null)
4684            if (Configuration.errorOnAutoCreate())
4685              throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.strength");
4686            else if (Configuration.doAutoCreate())
4687              this.strength = new Enumeration<BindingStrength>(new BindingStrengthEnumFactory()); // bb
4688          return this.strength;
4689        }
4690
4691        public boolean hasStrengthElement() { 
4692          return this.strength != null && !this.strength.isEmpty();
4693        }
4694
4695        public boolean hasStrength() { 
4696          return this.strength != null && !this.strength.isEmpty();
4697        }
4698
4699        /**
4700         * @param value {@link #strength} (Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.). This is the underlying object with id, value and extensions. The accessor "getStrength" gives direct access to the value
4701         */
4702        public ElementDefinitionBindingComponent setStrengthElement(Enumeration<BindingStrength> value) { 
4703          this.strength = value;
4704          return this;
4705        }
4706
4707        /**
4708         * @return Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.
4709         */
4710        public BindingStrength getStrength() { 
4711          return this.strength == null ? null : this.strength.getValue();
4712        }
4713
4714        /**
4715         * @param value Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.
4716         */
4717        public ElementDefinitionBindingComponent setStrength(BindingStrength value) { 
4718            if (this.strength == null)
4719              this.strength = new Enumeration<BindingStrength>(new BindingStrengthEnumFactory());
4720            this.strength.setValue(value);
4721          return this;
4722        }
4723
4724        /**
4725         * @return {@link #description} (Describes the intended use of this particular set of codes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4726         */
4727        public MarkdownType getDescriptionElement() { 
4728          if (this.description == null)
4729            if (Configuration.errorOnAutoCreate())
4730              throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.description");
4731            else if (Configuration.doAutoCreate())
4732              this.description = new MarkdownType(); // bb
4733          return this.description;
4734        }
4735
4736        public boolean hasDescriptionElement() { 
4737          return this.description != null && !this.description.isEmpty();
4738        }
4739
4740        public boolean hasDescription() { 
4741          return this.description != null && !this.description.isEmpty();
4742        }
4743
4744        /**
4745         * @param value {@link #description} (Describes the intended use of this particular set of codes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4746         */
4747        public ElementDefinitionBindingComponent setDescriptionElement(MarkdownType value) { 
4748          this.description = value;
4749          return this;
4750        }
4751
4752        /**
4753         * @return Describes the intended use of this particular set of codes.
4754         */
4755        public String getDescription() { 
4756          return this.description == null ? null : this.description.getValue();
4757        }
4758
4759        /**
4760         * @param value Describes the intended use of this particular set of codes.
4761         */
4762        public ElementDefinitionBindingComponent setDescription(String value) { 
4763          if (Utilities.noString(value))
4764            this.description = null;
4765          else {
4766            if (this.description == null)
4767              this.description = new MarkdownType();
4768            this.description.setValue(value);
4769          }
4770          return this;
4771        }
4772
4773        /**
4774         * @return {@link #valueSet} (Refers to the value set that identifies the set of codes the binding refers to.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value
4775         */
4776        public CanonicalType getValueSetElement() { 
4777          if (this.valueSet == null)
4778            if (Configuration.errorOnAutoCreate())
4779              throw new Error("Attempt to auto-create ElementDefinitionBindingComponent.valueSet");
4780            else if (Configuration.doAutoCreate())
4781              this.valueSet = new CanonicalType(); // bb
4782          return this.valueSet;
4783        }
4784
4785        public boolean hasValueSetElement() { 
4786          return this.valueSet != null && !this.valueSet.isEmpty();
4787        }
4788
4789        public boolean hasValueSet() { 
4790          return this.valueSet != null && !this.valueSet.isEmpty();
4791        }
4792
4793        /**
4794         * @param value {@link #valueSet} (Refers to the value set that identifies the set of codes the binding refers to.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value
4795         */
4796        public ElementDefinitionBindingComponent setValueSetElement(CanonicalType value) { 
4797          this.valueSet = value;
4798          return this;
4799        }
4800
4801        /**
4802         * @return Refers to the value set that identifies the set of codes the binding refers to.
4803         */
4804        public String getValueSet() { 
4805          return this.valueSet == null ? null : this.valueSet.getValue();
4806        }
4807
4808        /**
4809         * @param value Refers to the value set that identifies the set of codes the binding refers to.
4810         */
4811        public ElementDefinitionBindingComponent setValueSet(String value) { 
4812          if (Utilities.noString(value))
4813            this.valueSet = null;
4814          else {
4815            if (this.valueSet == null)
4816              this.valueSet = new CanonicalType();
4817            this.valueSet.setValue(value);
4818          }
4819          return this;
4820        }
4821
4822        /**
4823         * @return {@link #additional} (Additional bindings that help applications implementing this element. Additional bindings do not replace the main binding but provide more information and/or context.)
4824         */
4825        public List<ElementDefinitionBindingAdditionalComponent> getAdditional() { 
4826          if (this.additional == null)
4827            this.additional = new ArrayList<ElementDefinitionBindingAdditionalComponent>();
4828          return this.additional;
4829        }
4830
4831        /**
4832         * @return Returns a reference to <code>this</code> for easy method chaining
4833         */
4834        public ElementDefinitionBindingComponent setAdditional(List<ElementDefinitionBindingAdditionalComponent> theAdditional) { 
4835          this.additional = theAdditional;
4836          return this;
4837        }
4838
4839        public boolean hasAdditional() { 
4840          if (this.additional == null)
4841            return false;
4842          for (ElementDefinitionBindingAdditionalComponent item : this.additional)
4843            if (!item.isEmpty())
4844              return true;
4845          return false;
4846        }
4847
4848        public ElementDefinitionBindingAdditionalComponent addAdditional() { //3
4849          ElementDefinitionBindingAdditionalComponent t = new ElementDefinitionBindingAdditionalComponent();
4850          if (this.additional == null)
4851            this.additional = new ArrayList<ElementDefinitionBindingAdditionalComponent>();
4852          this.additional.add(t);
4853          return t;
4854        }
4855
4856        public ElementDefinitionBindingComponent addAdditional(ElementDefinitionBindingAdditionalComponent t) { //3
4857          if (t == null)
4858            return this;
4859          if (this.additional == null)
4860            this.additional = new ArrayList<ElementDefinitionBindingAdditionalComponent>();
4861          this.additional.add(t);
4862          return this;
4863        }
4864
4865        /**
4866         * @return The first repetition of repeating field {@link #additional}, creating it if it does not already exist {3}
4867         */
4868        public ElementDefinitionBindingAdditionalComponent getAdditionalFirstRep() { 
4869          if (getAdditional().isEmpty()) {
4870            addAdditional();
4871          }
4872          return getAdditional().get(0);
4873        }
4874
4875        protected void listChildren(List<Property> children) {
4876          super.listChildren(children);
4877          children.add(new Property("strength", "code", "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.", 0, 1, strength));
4878          children.add(new Property("description", "markdown", "Describes the intended use of this particular set of codes.", 0, 1, description));
4879          children.add(new Property("valueSet", "canonical(ValueSet)", "Refers to the value set that identifies the set of codes the binding refers to.", 0, 1, valueSet));
4880          children.add(new Property("additional", "", "Additional bindings that help applications implementing this element. Additional bindings do not replace the main binding but provide more information and/or context.", 0, java.lang.Integer.MAX_VALUE, additional));
4881        }
4882
4883        @Override
4884        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4885          switch (_hash) {
4886          case 1791316033: /*strength*/  return new Property("strength", "code", "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.", 0, 1, strength);
4887          case -1724546052: /*description*/  return new Property("description", "markdown", "Describes the intended use of this particular set of codes.", 0, 1, description);
4888          case -1410174671: /*valueSet*/  return new Property("valueSet", "canonical(ValueSet)", "Refers to the value set that identifies the set of codes the binding refers to.", 0, 1, valueSet);
4889          case -1931413465: /*additional*/  return new Property("additional", "", "Additional bindings that help applications implementing this element. Additional bindings do not replace the main binding but provide more information and/or context.", 0, java.lang.Integer.MAX_VALUE, additional);
4890          default: return super.getNamedProperty(_hash, _name, _checkValid);
4891          }
4892
4893        }
4894
4895      @Override
4896      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4897        switch (hash) {
4898        case 1791316033: /*strength*/ return this.strength == null ? new Base[0] : new Base[] {this.strength}; // Enumeration<BindingStrength>
4899        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
4900        case -1410174671: /*valueSet*/ return this.valueSet == null ? new Base[0] : new Base[] {this.valueSet}; // CanonicalType
4901        case -1931413465: /*additional*/ return this.additional == null ? new Base[0] : this.additional.toArray(new Base[this.additional.size()]); // ElementDefinitionBindingAdditionalComponent
4902        default: return super.getProperty(hash, name, checkValid);
4903        }
4904
4905      }
4906
4907      @Override
4908      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4909        switch (hash) {
4910        case 1791316033: // strength
4911          value = new BindingStrengthEnumFactory().fromType(TypeConvertor.castToCode(value));
4912          this.strength = (Enumeration) value; // Enumeration<BindingStrength>
4913          return value;
4914        case -1724546052: // description
4915          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
4916          return value;
4917        case -1410174671: // valueSet
4918          this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType
4919          return value;
4920        case -1931413465: // additional
4921          this.getAdditional().add((ElementDefinitionBindingAdditionalComponent) value); // ElementDefinitionBindingAdditionalComponent
4922          return value;
4923        default: return super.setProperty(hash, name, value);
4924        }
4925
4926      }
4927
4928      @Override
4929      public Base setProperty(String name, Base value) throws FHIRException {
4930        if (name.equals("strength")) {
4931          value = new BindingStrengthEnumFactory().fromType(TypeConvertor.castToCode(value));
4932          this.strength = (Enumeration) value; // Enumeration<BindingStrength>
4933        } else if (name.equals("description")) {
4934          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
4935        } else if (name.equals("valueSet")) {
4936          this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType
4937        } else if (name.equals("additional")) {
4938          this.getAdditional().add((ElementDefinitionBindingAdditionalComponent) value);
4939        } else
4940          return super.setProperty(name, value);
4941        return value;
4942      }
4943
4944  @Override
4945  public void removeChild(String name, Base value) throws FHIRException {
4946        if (name.equals("strength")) {
4947          value = new BindingStrengthEnumFactory().fromType(TypeConvertor.castToCode(value));
4948          this.strength = (Enumeration) value; // Enumeration<BindingStrength>
4949        } else if (name.equals("description")) {
4950          this.description = null;
4951        } else if (name.equals("valueSet")) {
4952          this.valueSet = null;
4953        } else if (name.equals("additional")) {
4954          this.getAdditional().remove((ElementDefinitionBindingAdditionalComponent) value);
4955        } else
4956          super.removeChild(name, value);
4957        
4958      }
4959
4960      @Override
4961      public Base makeProperty(int hash, String name) throws FHIRException {
4962        switch (hash) {
4963        case 1791316033:  return getStrengthElement();
4964        case -1724546052:  return getDescriptionElement();
4965        case -1410174671:  return getValueSetElement();
4966        case -1931413465:  return addAdditional(); 
4967        default: return super.makeProperty(hash, name);
4968        }
4969
4970      }
4971
4972      @Override
4973      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4974        switch (hash) {
4975        case 1791316033: /*strength*/ return new String[] {"code"};
4976        case -1724546052: /*description*/ return new String[] {"markdown"};
4977        case -1410174671: /*valueSet*/ return new String[] {"canonical"};
4978        case -1931413465: /*additional*/ return new String[] {};
4979        default: return super.getTypesForProperty(hash, name);
4980        }
4981
4982      }
4983
4984      @Override
4985      public Base addChild(String name) throws FHIRException {
4986        if (name.equals("strength")) {
4987          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.strength");
4988        }
4989        else if (name.equals("description")) {
4990          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.description");
4991        }
4992        else if (name.equals("valueSet")) {
4993          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.valueSet");
4994        }
4995        else if (name.equals("additional")) {
4996          return addAdditional();
4997        }
4998        else
4999          return super.addChild(name);
5000      }
5001
5002      public ElementDefinitionBindingComponent copy() {
5003        ElementDefinitionBindingComponent dst = new ElementDefinitionBindingComponent();
5004        copyValues(dst);
5005        return dst;
5006      }
5007
5008      public void copyValues(ElementDefinitionBindingComponent dst) {
5009        super.copyValues(dst);
5010        dst.strength = strength == null ? null : strength.copy();
5011        dst.description = description == null ? null : description.copy();
5012        dst.valueSet = valueSet == null ? null : valueSet.copy();
5013        if (additional != null) {
5014          dst.additional = new ArrayList<ElementDefinitionBindingAdditionalComponent>();
5015          for (ElementDefinitionBindingAdditionalComponent i : additional)
5016            dst.additional.add(i.copy());
5017        };
5018      }
5019
5020      @Override
5021      public boolean equalsDeep(Base other_) {
5022        if (!super.equalsDeep(other_))
5023          return false;
5024        if (!(other_ instanceof ElementDefinitionBindingComponent))
5025          return false;
5026        ElementDefinitionBindingComponent o = (ElementDefinitionBindingComponent) other_;
5027        return compareDeep(strength, o.strength, true) && compareDeep(description, o.description, true)
5028           && compareDeep(valueSet, o.valueSet, true) && compareDeep(additional, o.additional, true);
5029      }
5030
5031      @Override
5032      public boolean equalsShallow(Base other_) {
5033        if (!super.equalsShallow(other_))
5034          return false;
5035        if (!(other_ instanceof ElementDefinitionBindingComponent))
5036          return false;
5037        ElementDefinitionBindingComponent o = (ElementDefinitionBindingComponent) other_;
5038        return compareValues(strength, o.strength, true) && compareValues(description, o.description, true)
5039           && compareValues(valueSet, o.valueSet, true);
5040      }
5041
5042      public boolean isEmpty() {
5043        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(strength, description, valueSet
5044          , additional);
5045      }
5046
5047  public String fhirType() {
5048    return "ElementDefinition.binding";
5049
5050  }
5051
5052  public boolean hasAdditional(ElementDefinitionBindingAdditionalComponent ab) {
5053    if (hasAdditional()) {
5054      for (ElementDefinitionBindingAdditionalComponent t : getAdditional()) {
5055        if (Base.compareDeep(t, ab, false)) {
5056          return true;
5057        }
5058      }
5059    }
5060    return false;
5061  }
5062
5063  }
5064
5065    @Block()
5066    public static class ElementDefinitionBindingAdditionalComponent extends Element implements IBaseDatatypeElement {
5067        /**
5068         * The use of this additional binding.
5069         */
5070        @Child(name = "purpose", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
5071        @Description(shortDefinition="maximum | minimum | required | extensible | candidate | current | preferred | ui | starter | component", formalDefinition="The use of this additional binding." )
5072        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/additional-binding-purpose")
5073        protected Enumeration<AdditionalBindingPurposeVS> purpose;
5074
5075        /**
5076         * The valueSet that is being bound for the purpose.
5077         */
5078        @Child(name = "valueSet", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true)
5079        @Description(shortDefinition="The value set for the additional binding", formalDefinition="The valueSet that is being bound for the purpose." )
5080        protected CanonicalType valueSet;
5081
5082        /**
5083         * Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.
5084         */
5085        @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=true)
5086        @Description(shortDefinition="Documentation of the purpose of use of the binding", formalDefinition="Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used." )
5087        protected MarkdownType documentation;
5088
5089        /**
5090         * Concise documentation - for summary tables.
5091         */
5092        @Child(name = "shortDoco", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
5093        @Description(shortDefinition="Concise documentation - for summary tables", formalDefinition="Concise documentation - for summary tables." )
5094        protected StringType shortDoco;
5095
5096        /**
5097         * Qualifies the usage of the binding. Typically bindings are qualified by jurisdiction, but they may also be qualified by gender, workflow status, clinical domain etc. The information to decide whether a usege context applies is usually outside the resource, determined by context, and this might present challenges for validation tooling.
5098         */
5099        @Child(name = "usage", type = {UsageContext.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5100        @Description(shortDefinition="Qualifies the usage - jurisdiction, gender, workflow status etc.", formalDefinition="Qualifies the usage of the binding. Typically bindings are qualified by jurisdiction, but they may also be qualified by gender, workflow status, clinical domain etc. The information to decide whether a usege context applies is usually outside the resource, determined by context, and this might present challenges for validation tooling." )
5101        protected List<UsageContext> usage;
5102
5103        /**
5104         * Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.
5105         */
5106        @Child(name = "any", type = {BooleanType.class}, order=6, min=0, max=1, modifier=false, summary=true)
5107        @Description(shortDefinition="Whether binding can applies to all repeats, or just one", formalDefinition="Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat." )
5108        protected BooleanType any;
5109
5110        private static final long serialVersionUID = -1312796441L;
5111
5112    /**
5113     * Constructor
5114     */
5115      public ElementDefinitionBindingAdditionalComponent() {
5116        super();
5117      }
5118
5119    /**
5120     * Constructor
5121     */
5122      public ElementDefinitionBindingAdditionalComponent(AdditionalBindingPurposeVS purpose, String valueSet) {
5123        super();
5124        this.setPurpose(purpose);
5125        this.setValueSet(valueSet);
5126      }
5127
5128        /**
5129         * @return {@link #purpose} (The use of this additional binding.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
5130         */
5131        public Enumeration<AdditionalBindingPurposeVS> getPurposeElement() { 
5132          if (this.purpose == null)
5133            if (Configuration.errorOnAutoCreate())
5134              throw new Error("Attempt to auto-create ElementDefinitionBindingAdditionalComponent.purpose");
5135            else if (Configuration.doAutoCreate())
5136              this.purpose = new Enumeration<AdditionalBindingPurposeVS>(new AdditionalBindingPurposeVSEnumFactory()); // bb
5137          return this.purpose;
5138        }
5139
5140        public boolean hasPurposeElement() { 
5141          return this.purpose != null && !this.purpose.isEmpty();
5142        }
5143
5144        public boolean hasPurpose() { 
5145          return this.purpose != null && !this.purpose.isEmpty();
5146        }
5147
5148        /**
5149         * @param value {@link #purpose} (The use of this additional binding.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
5150         */
5151        public ElementDefinitionBindingAdditionalComponent setPurposeElement(Enumeration<AdditionalBindingPurposeVS> value) { 
5152          this.purpose = value;
5153          return this;
5154        }
5155
5156        /**
5157         * @return The use of this additional binding.
5158         */
5159        public AdditionalBindingPurposeVS getPurpose() { 
5160          return this.purpose == null ? null : this.purpose.getValue();
5161        }
5162
5163        /**
5164         * @param value The use of this additional binding.
5165         */
5166        public ElementDefinitionBindingAdditionalComponent setPurpose(AdditionalBindingPurposeVS value) { 
5167            if (this.purpose == null)
5168              this.purpose = new Enumeration<AdditionalBindingPurposeVS>(new AdditionalBindingPurposeVSEnumFactory());
5169            this.purpose.setValue(value);
5170          return this;
5171        }
5172
5173        /**
5174         * @return {@link #valueSet} (The valueSet that is being bound for the purpose.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value
5175         */
5176        public CanonicalType getValueSetElement() { 
5177          if (this.valueSet == null)
5178            if (Configuration.errorOnAutoCreate())
5179              throw new Error("Attempt to auto-create ElementDefinitionBindingAdditionalComponent.valueSet");
5180            else if (Configuration.doAutoCreate())
5181              this.valueSet = new CanonicalType(); // bb
5182          return this.valueSet;
5183        }
5184
5185        public boolean hasValueSetElement() { 
5186          return this.valueSet != null && !this.valueSet.isEmpty();
5187        }
5188
5189        public boolean hasValueSet() { 
5190          return this.valueSet != null && !this.valueSet.isEmpty();
5191        }
5192
5193        /**
5194         * @param value {@link #valueSet} (The valueSet that is being bound for the purpose.). This is the underlying object with id, value and extensions. The accessor "getValueSet" gives direct access to the value
5195         */
5196        public ElementDefinitionBindingAdditionalComponent setValueSetElement(CanonicalType value) { 
5197          this.valueSet = value;
5198          return this;
5199        }
5200
5201        /**
5202         * @return The valueSet that is being bound for the purpose.
5203         */
5204        public String getValueSet() { 
5205          return this.valueSet == null ? null : this.valueSet.getValue();
5206        }
5207
5208        /**
5209         * @param value The valueSet that is being bound for the purpose.
5210         */
5211        public ElementDefinitionBindingAdditionalComponent setValueSet(String value) { 
5212            if (this.valueSet == null)
5213              this.valueSet = new CanonicalType();
5214            this.valueSet.setValue(value);
5215          return this;
5216        }
5217
5218        /**
5219         * @return {@link #documentation} (Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
5220         */
5221        public MarkdownType getDocumentationElement() { 
5222          if (this.documentation == null)
5223            if (Configuration.errorOnAutoCreate())
5224              throw new Error("Attempt to auto-create ElementDefinitionBindingAdditionalComponent.documentation");
5225            else if (Configuration.doAutoCreate())
5226              this.documentation = new MarkdownType(); // bb
5227          return this.documentation;
5228        }
5229
5230        public boolean hasDocumentationElement() { 
5231          return this.documentation != null && !this.documentation.isEmpty();
5232        }
5233
5234        public boolean hasDocumentation() { 
5235          return this.documentation != null && !this.documentation.isEmpty();
5236        }
5237
5238        /**
5239         * @param value {@link #documentation} (Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
5240         */
5241        public ElementDefinitionBindingAdditionalComponent setDocumentationElement(MarkdownType value) { 
5242          this.documentation = value;
5243          return this;
5244        }
5245
5246        /**
5247         * @return Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.
5248         */
5249        public String getDocumentation() { 
5250          return this.documentation == null ? null : this.documentation.getValue();
5251        }
5252
5253        /**
5254         * @param value Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.
5255         */
5256        public ElementDefinitionBindingAdditionalComponent setDocumentation(String value) { 
5257          if (Utilities.noString(value))
5258            this.documentation = null;
5259          else {
5260            if (this.documentation == null)
5261              this.documentation = new MarkdownType();
5262            this.documentation.setValue(value);
5263          }
5264          return this;
5265        }
5266
5267        /**
5268         * @return {@link #shortDoco} (Concise documentation - for summary tables.). This is the underlying object with id, value and extensions. The accessor "getShortDoco" gives direct access to the value
5269         */
5270        public StringType getShortDocoElement() { 
5271          if (this.shortDoco == null)
5272            if (Configuration.errorOnAutoCreate())
5273              throw new Error("Attempt to auto-create ElementDefinitionBindingAdditionalComponent.shortDoco");
5274            else if (Configuration.doAutoCreate())
5275              this.shortDoco = new StringType(); // bb
5276          return this.shortDoco;
5277        }
5278
5279        public boolean hasShortDocoElement() { 
5280          return this.shortDoco != null && !this.shortDoco.isEmpty();
5281        }
5282
5283        public boolean hasShortDoco() { 
5284          return this.shortDoco != null && !this.shortDoco.isEmpty();
5285        }
5286
5287        /**
5288         * @param value {@link #shortDoco} (Concise documentation - for summary tables.). This is the underlying object with id, value and extensions. The accessor "getShortDoco" gives direct access to the value
5289         */
5290        public ElementDefinitionBindingAdditionalComponent setShortDocoElement(StringType value) { 
5291          this.shortDoco = value;
5292          return this;
5293        }
5294
5295        /**
5296         * @return Concise documentation - for summary tables.
5297         */
5298        public String getShortDoco() { 
5299          return this.shortDoco == null ? null : this.shortDoco.getValue();
5300        }
5301
5302        /**
5303         * @param value Concise documentation - for summary tables.
5304         */
5305        public ElementDefinitionBindingAdditionalComponent setShortDoco(String value) { 
5306          if (Utilities.noString(value))
5307            this.shortDoco = null;
5308          else {
5309            if (this.shortDoco == null)
5310              this.shortDoco = new StringType();
5311            this.shortDoco.setValue(value);
5312          }
5313          return this;
5314        }
5315
5316        /**
5317         * @return {@link #usage} (Qualifies the usage of the binding. Typically bindings are qualified by jurisdiction, but they may also be qualified by gender, workflow status, clinical domain etc. The information to decide whether a usege context applies is usually outside the resource, determined by context, and this might present challenges for validation tooling.)
5318         */
5319        public List<UsageContext> getUsage() { 
5320          if (this.usage == null)
5321            this.usage = new ArrayList<UsageContext>();
5322          return this.usage;
5323        }
5324
5325        /**
5326         * @return Returns a reference to <code>this</code> for easy method chaining
5327         */
5328        public ElementDefinitionBindingAdditionalComponent setUsage(List<UsageContext> theUsage) { 
5329          this.usage = theUsage;
5330          return this;
5331        }
5332
5333        public boolean hasUsage() { 
5334          if (this.usage == null)
5335            return false;
5336          for (UsageContext item : this.usage)
5337            if (!item.isEmpty())
5338              return true;
5339          return false;
5340        }
5341
5342        public UsageContext addUsage() { //3
5343          UsageContext t = new UsageContext();
5344          if (this.usage == null)
5345            this.usage = new ArrayList<UsageContext>();
5346          this.usage.add(t);
5347          return t;
5348        }
5349
5350        public ElementDefinitionBindingAdditionalComponent addUsage(UsageContext t) { //3
5351          if (t == null)
5352            return this;
5353          if (this.usage == null)
5354            this.usage = new ArrayList<UsageContext>();
5355          this.usage.add(t);
5356          return this;
5357        }
5358
5359        /**
5360         * @return The first repetition of repeating field {@link #usage}, creating it if it does not already exist {3}
5361         */
5362        public UsageContext getUsageFirstRep() { 
5363          if (getUsage().isEmpty()) {
5364            addUsage();
5365          }
5366          return getUsage().get(0);
5367        }
5368
5369        /**
5370         * @return {@link #any} (Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.). This is the underlying object with id, value and extensions. The accessor "getAny" gives direct access to the value
5371         */
5372        public BooleanType getAnyElement() { 
5373          if (this.any == null)
5374            if (Configuration.errorOnAutoCreate())
5375              throw new Error("Attempt to auto-create ElementDefinitionBindingAdditionalComponent.any");
5376            else if (Configuration.doAutoCreate())
5377              this.any = new BooleanType(); // bb
5378          return this.any;
5379        }
5380
5381        public boolean hasAnyElement() { 
5382          return this.any != null && !this.any.isEmpty();
5383        }
5384
5385        public boolean hasAny() { 
5386          return this.any != null && !this.any.isEmpty();
5387        }
5388
5389        /**
5390         * @param value {@link #any} (Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.). This is the underlying object with id, value and extensions. The accessor "getAny" gives direct access to the value
5391         */
5392        public ElementDefinitionBindingAdditionalComponent setAnyElement(BooleanType value) { 
5393          this.any = value;
5394          return this;
5395        }
5396
5397        /**
5398         * @return Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.
5399         */
5400        public boolean getAny() { 
5401          return this.any == null || this.any.isEmpty() ? false : this.any.getValue();
5402        }
5403
5404        /**
5405         * @param value Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.
5406         */
5407        public ElementDefinitionBindingAdditionalComponent setAny(boolean value) { 
5408            if (this.any == null)
5409              this.any = new BooleanType();
5410            this.any.setValue(value);
5411          return this;
5412        }
5413
5414        protected void listChildren(List<Property> children) {
5415          super.listChildren(children);
5416          children.add(new Property("purpose", "code", "The use of this additional binding.", 0, 1, purpose));
5417          children.add(new Property("valueSet", "canonical(ValueSet)", "The valueSet that is being bound for the purpose.", 0, 1, valueSet));
5418          children.add(new Property("documentation", "markdown", "Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.", 0, 1, documentation));
5419          children.add(new Property("shortDoco", "string", "Concise documentation - for summary tables.", 0, 1, shortDoco));
5420          children.add(new Property("usage", "UsageContext", "Qualifies the usage of the binding. Typically bindings are qualified by jurisdiction, but they may also be qualified by gender, workflow status, clinical domain etc. The information to decide whether a usege context applies is usually outside the resource, determined by context, and this might present challenges for validation tooling.", 0, java.lang.Integer.MAX_VALUE, usage));
5421          children.add(new Property("any", "boolean", "Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.", 0, 1, any));
5422        }
5423
5424        @Override
5425        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5426          switch (_hash) {
5427          case -220463842: /*purpose*/  return new Property("purpose", "code", "The use of this additional binding.", 0, 1, purpose);
5428          case -1410174671: /*valueSet*/  return new Property("valueSet", "canonical(ValueSet)", "The valueSet that is being bound for the purpose.", 0, 1, valueSet);
5429          case 1587405498: /*documentation*/  return new Property("documentation", "markdown", "Documentation of the purpose of use of the bindingproviding additional information about how it is intended to be used.", 0, 1, documentation);
5430          case -2028503853: /*shortDoco*/  return new Property("shortDoco", "string", "Concise documentation - for summary tables.", 0, 1, shortDoco);
5431          case 111574433: /*usage*/  return new Property("usage", "UsageContext", "Qualifies the usage of the binding. Typically bindings are qualified by jurisdiction, but they may also be qualified by gender, workflow status, clinical domain etc. The information to decide whether a usege context applies is usually outside the resource, determined by context, and this might present challenges for validation tooling.", 0, java.lang.Integer.MAX_VALUE, usage);
5432          case 96748: /*any*/  return new Property("any", "boolean", "Whether the binding applies to all repeats, or just to any one of them. This is only relevant for elements that can repeat.", 0, 1, any);
5433          default: return super.getNamedProperty(_hash, _name, _checkValid);
5434          }
5435
5436        }
5437
5438      @Override
5439      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5440        switch (hash) {
5441        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // Enumeration<AdditionalBindingPurposeVS>
5442        case -1410174671: /*valueSet*/ return this.valueSet == null ? new Base[0] : new Base[] {this.valueSet}; // CanonicalType
5443        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
5444        case -2028503853: /*shortDoco*/ return this.shortDoco == null ? new Base[0] : new Base[] {this.shortDoco}; // StringType
5445        case 111574433: /*usage*/ return this.usage == null ? new Base[0] : this.usage.toArray(new Base[this.usage.size()]); // UsageContext
5446        case 96748: /*any*/ return this.any == null ? new Base[0] : new Base[] {this.any}; // BooleanType
5447        default: return super.getProperty(hash, name, checkValid);
5448        }
5449
5450      }
5451
5452      @Override
5453      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5454        switch (hash) {
5455        case -220463842: // purpose
5456          value = new AdditionalBindingPurposeVSEnumFactory().fromType(TypeConvertor.castToCode(value));
5457          this.purpose = (Enumeration) value; // Enumeration<AdditionalBindingPurposeVS>
5458          return value;
5459        case -1410174671: // valueSet
5460          this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType
5461          return value;
5462        case 1587405498: // documentation
5463          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5464          return value;
5465        case -2028503853: // shortDoco
5466          this.shortDoco = TypeConvertor.castToString(value); // StringType
5467          return value;
5468        case 111574433: // usage
5469          this.getUsage().add(TypeConvertor.castToUsageContext(value)); // UsageContext
5470          return value;
5471        case 96748: // any
5472          this.any = TypeConvertor.castToBoolean(value); // BooleanType
5473          return value;
5474        default: return super.setProperty(hash, name, value);
5475        }
5476
5477      }
5478
5479      @Override
5480      public Base setProperty(String name, Base value) throws FHIRException {
5481        if (name.equals("purpose")) {
5482          value = new AdditionalBindingPurposeVSEnumFactory().fromType(TypeConvertor.castToCode(value));
5483          this.purpose = (Enumeration) value; // Enumeration<AdditionalBindingPurposeVS>
5484        } else if (name.equals("valueSet")) {
5485          this.valueSet = TypeConvertor.castToCanonical(value); // CanonicalType
5486        } else if (name.equals("documentation")) {
5487          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5488        } else if (name.equals("shortDoco")) {
5489          this.shortDoco = TypeConvertor.castToString(value); // StringType
5490        } else if (name.equals("usage")) {
5491          this.getUsage().add(TypeConvertor.castToUsageContext(value));
5492        } else if (name.equals("any")) {
5493          this.any = TypeConvertor.castToBoolean(value); // BooleanType
5494        } else
5495          return super.setProperty(name, value);
5496        return value;
5497      }
5498
5499  @Override
5500  public void removeChild(String name, Base value) throws FHIRException {
5501        if (name.equals("purpose")) {
5502          value = new AdditionalBindingPurposeVSEnumFactory().fromType(TypeConvertor.castToCode(value));
5503          this.purpose = (Enumeration) value; // Enumeration<AdditionalBindingPurposeVS>
5504        } else if (name.equals("valueSet")) {
5505          this.valueSet = null;
5506        } else if (name.equals("documentation")) {
5507          this.documentation = null;
5508        } else if (name.equals("shortDoco")) {
5509          this.shortDoco = null;
5510        } else if (name.equals("usage")) {
5511          this.getUsage().remove(value);
5512        } else if (name.equals("any")) {
5513          this.any = null;
5514        } else
5515          super.removeChild(name, value);
5516        
5517      }
5518
5519      @Override
5520      public Base makeProperty(int hash, String name) throws FHIRException {
5521        switch (hash) {
5522        case -220463842:  return getPurposeElement();
5523        case -1410174671:  return getValueSetElement();
5524        case 1587405498:  return getDocumentationElement();
5525        case -2028503853:  return getShortDocoElement();
5526        case 111574433:  return addUsage(); 
5527        case 96748:  return getAnyElement();
5528        default: return super.makeProperty(hash, name);
5529        }
5530
5531      }
5532
5533      @Override
5534      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5535        switch (hash) {
5536        case -220463842: /*purpose*/ return new String[] {"code"};
5537        case -1410174671: /*valueSet*/ return new String[] {"canonical"};
5538        case 1587405498: /*documentation*/ return new String[] {"markdown"};
5539        case -2028503853: /*shortDoco*/ return new String[] {"string"};
5540        case 111574433: /*usage*/ return new String[] {"UsageContext"};
5541        case 96748: /*any*/ return new String[] {"boolean"};
5542        default: return super.getTypesForProperty(hash, name);
5543        }
5544
5545      }
5546
5547      @Override
5548      public Base addChild(String name) throws FHIRException {
5549        if (name.equals("purpose")) {
5550          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.additional.purpose");
5551        }
5552        else if (name.equals("valueSet")) {
5553          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.additional.valueSet");
5554        }
5555        else if (name.equals("documentation")) {
5556          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.additional.documentation");
5557        }
5558        else if (name.equals("shortDoco")) {
5559          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.additional.shortDoco");
5560        }
5561        else if (name.equals("usage")) {
5562          return addUsage();
5563        }
5564        else if (name.equals("any")) {
5565          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.binding.additional.any");
5566        }
5567        else
5568          return super.addChild(name);
5569      }
5570
5571      public ElementDefinitionBindingAdditionalComponent copy() {
5572        ElementDefinitionBindingAdditionalComponent dst = new ElementDefinitionBindingAdditionalComponent();
5573        copyValues(dst);
5574        return dst;
5575      }
5576
5577      public void copyValues(ElementDefinitionBindingAdditionalComponent dst) {
5578        super.copyValues(dst);
5579        dst.purpose = purpose == null ? null : purpose.copy();
5580        dst.valueSet = valueSet == null ? null : valueSet.copy();
5581        dst.documentation = documentation == null ? null : documentation.copy();
5582        dst.shortDoco = shortDoco == null ? null : shortDoco.copy();
5583        if (usage != null) {
5584          dst.usage = new ArrayList<UsageContext>();
5585          for (UsageContext i : usage)
5586            dst.usage.add(i.copy());
5587        };
5588        dst.any = any == null ? null : any.copy();
5589      }
5590
5591      @Override
5592      public boolean equalsDeep(Base other_) {
5593        if (!super.equalsDeep(other_))
5594          return false;
5595        if (!(other_ instanceof ElementDefinitionBindingAdditionalComponent))
5596          return false;
5597        ElementDefinitionBindingAdditionalComponent o = (ElementDefinitionBindingAdditionalComponent) other_;
5598        return compareDeep(purpose, o.purpose, true) && compareDeep(valueSet, o.valueSet, true) && compareDeep(documentation, o.documentation, true)
5599           && compareDeep(shortDoco, o.shortDoco, true) && compareDeep(usage, o.usage, true) && compareDeep(any, o.any, true)
5600          ;
5601      }
5602
5603      @Override
5604      public boolean equalsShallow(Base other_) {
5605        if (!super.equalsShallow(other_))
5606          return false;
5607        if (!(other_ instanceof ElementDefinitionBindingAdditionalComponent))
5608          return false;
5609        ElementDefinitionBindingAdditionalComponent o = (ElementDefinitionBindingAdditionalComponent) other_;
5610        return compareValues(purpose, o.purpose, true) && compareValues(valueSet, o.valueSet, true) && compareValues(documentation, o.documentation, true)
5611           && compareValues(shortDoco, o.shortDoco, true) && compareValues(any, o.any, true);
5612      }
5613
5614      public boolean isEmpty() {
5615        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, valueSet, documentation
5616          , shortDoco, usage, any);
5617      }
5618
5619  public String fhirType() {
5620    return "ElementDefinition.binding.additional";
5621
5622  }
5623
5624  }
5625
5626    @Block()
5627    public static class ElementDefinitionMappingComponent extends Element implements IBaseDatatypeElement {
5628        @Override
5629      public String toString() {
5630        return identity+"=" + map;
5631      }
5632
5633        /**
5634         * An internal reference to the definition of a mapping.
5635         */
5636        @Child(name = "identity", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
5637        @Description(shortDefinition="Reference to mapping declaration", formalDefinition="An internal reference to the definition of a mapping." )
5638        protected IdType identity;
5639
5640        /**
5641         * Identifies the computable language in which mapping.map is expressed.
5642         */
5643        @Child(name = "language", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
5644        @Description(shortDefinition="Computable language of mapping", formalDefinition="Identifies the computable language in which mapping.map is expressed." )
5645        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
5646        protected CodeType language;
5647
5648        /**
5649         * Expresses what part of the target specification corresponds to this element.
5650         */
5651        @Child(name = "map", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true)
5652        @Description(shortDefinition="Details of the mapping", formalDefinition="Expresses what part of the target specification corresponds to this element." )
5653        protected StringType map;
5654
5655        /**
5656         * Comments that provide information about the mapping or its use.
5657         */
5658        @Child(name = "comment", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=true)
5659        @Description(shortDefinition="Comments about the mapping or its use", formalDefinition="Comments that provide information about the mapping or its use." )
5660        protected MarkdownType comment;
5661
5662        private static final long serialVersionUID = -582458727L;
5663
5664    /**
5665     * Constructor
5666     */
5667      public ElementDefinitionMappingComponent() {
5668        super();
5669      }
5670
5671    /**
5672     * Constructor
5673     */
5674      public ElementDefinitionMappingComponent(String identity, String map) {
5675        super();
5676        this.setIdentity(identity);
5677        this.setMap(map);
5678      }
5679
5680        /**
5681         * @return {@link #identity} (An internal reference to the definition of a mapping.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
5682         */
5683        public IdType getIdentityElement() { 
5684          if (this.identity == null)
5685            if (Configuration.errorOnAutoCreate())
5686              throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.identity");
5687            else if (Configuration.doAutoCreate())
5688              this.identity = new IdType(); // bb
5689          return this.identity;
5690        }
5691
5692        public boolean hasIdentityElement() { 
5693          return this.identity != null && !this.identity.isEmpty();
5694        }
5695
5696        public boolean hasIdentity() { 
5697          return this.identity != null && !this.identity.isEmpty();
5698        }
5699
5700        /**
5701         * @param value {@link #identity} (An internal reference to the definition of a mapping.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
5702         */
5703        public ElementDefinitionMappingComponent setIdentityElement(IdType value) { 
5704          this.identity = value;
5705          return this;
5706        }
5707
5708        /**
5709         * @return An internal reference to the definition of a mapping.
5710         */
5711        public String getIdentity() { 
5712          return this.identity == null ? null : this.identity.getValue();
5713        }
5714
5715        /**
5716         * @param value An internal reference to the definition of a mapping.
5717         */
5718        public ElementDefinitionMappingComponent setIdentity(String value) { 
5719            if (this.identity == null)
5720              this.identity = new IdType();
5721            this.identity.setValue(value);
5722          return this;
5723        }
5724
5725        /**
5726         * @return {@link #language} (Identifies the computable language in which mapping.map is expressed.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
5727         */
5728        public CodeType getLanguageElement() { 
5729          if (this.language == null)
5730            if (Configuration.errorOnAutoCreate())
5731              throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.language");
5732            else if (Configuration.doAutoCreate())
5733              this.language = new CodeType(); // bb
5734          return this.language;
5735        }
5736
5737        public boolean hasLanguageElement() { 
5738          return this.language != null && !this.language.isEmpty();
5739        }
5740
5741        public boolean hasLanguage() { 
5742          return this.language != null && !this.language.isEmpty();
5743        }
5744
5745        /**
5746         * @param value {@link #language} (Identifies the computable language in which mapping.map is expressed.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
5747         */
5748        public ElementDefinitionMappingComponent setLanguageElement(CodeType value) { 
5749          this.language = value;
5750          return this;
5751        }
5752
5753        /**
5754         * @return Identifies the computable language in which mapping.map is expressed.
5755         */
5756        public String getLanguage() { 
5757          return this.language == null ? null : this.language.getValue();
5758        }
5759
5760        /**
5761         * @param value Identifies the computable language in which mapping.map is expressed.
5762         */
5763        public ElementDefinitionMappingComponent setLanguage(String value) { 
5764          if (Utilities.noString(value))
5765            this.language = null;
5766          else {
5767            if (this.language == null)
5768              this.language = new CodeType();
5769            this.language.setValue(value);
5770          }
5771          return this;
5772        }
5773
5774        /**
5775         * @return {@link #map} (Expresses what part of the target specification corresponds to this element.). This is the underlying object with id, value and extensions. The accessor "getMap" gives direct access to the value
5776         */
5777        public StringType getMapElement() { 
5778          if (this.map == null)
5779            if (Configuration.errorOnAutoCreate())
5780              throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.map");
5781            else if (Configuration.doAutoCreate())
5782              this.map = new StringType(); // bb
5783          return this.map;
5784        }
5785
5786        public boolean hasMapElement() { 
5787          return this.map != null && !this.map.isEmpty();
5788        }
5789
5790        public boolean hasMap() { 
5791          return this.map != null && !this.map.isEmpty();
5792        }
5793
5794        /**
5795         * @param value {@link #map} (Expresses what part of the target specification corresponds to this element.). This is the underlying object with id, value and extensions. The accessor "getMap" gives direct access to the value
5796         */
5797        public ElementDefinitionMappingComponent setMapElement(StringType value) { 
5798          this.map = value;
5799          return this;
5800        }
5801
5802        /**
5803         * @return Expresses what part of the target specification corresponds to this element.
5804         */
5805        public String getMap() { 
5806          return this.map == null ? null : this.map.getValue();
5807        }
5808
5809        /**
5810         * @param value Expresses what part of the target specification corresponds to this element.
5811         */
5812        public ElementDefinitionMappingComponent setMap(String value) { 
5813            if (this.map == null)
5814              this.map = new StringType();
5815            this.map.setValue(value);
5816          return this;
5817        }
5818
5819        /**
5820         * @return {@link #comment} (Comments that provide information about the mapping or its use.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
5821         */
5822        public MarkdownType getCommentElement() { 
5823          if (this.comment == null)
5824            if (Configuration.errorOnAutoCreate())
5825              throw new Error("Attempt to auto-create ElementDefinitionMappingComponent.comment");
5826            else if (Configuration.doAutoCreate())
5827              this.comment = new MarkdownType(); // bb
5828          return this.comment;
5829        }
5830
5831        public boolean hasCommentElement() { 
5832          return this.comment != null && !this.comment.isEmpty();
5833        }
5834
5835        public boolean hasComment() { 
5836          return this.comment != null && !this.comment.isEmpty();
5837        }
5838
5839        /**
5840         * @param value {@link #comment} (Comments that provide information about the mapping or its use.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
5841         */
5842        public ElementDefinitionMappingComponent setCommentElement(MarkdownType value) { 
5843          this.comment = value;
5844          return this;
5845        }
5846
5847        /**
5848         * @return Comments that provide information about the mapping or its use.
5849         */
5850        public String getComment() { 
5851          return this.comment == null ? null : this.comment.getValue();
5852        }
5853
5854        /**
5855         * @param value Comments that provide information about the mapping or its use.
5856         */
5857        public ElementDefinitionMappingComponent setComment(String value) { 
5858          if (Utilities.noString(value))
5859            this.comment = null;
5860          else {
5861            if (this.comment == null)
5862              this.comment = new MarkdownType();
5863            this.comment.setValue(value);
5864          }
5865          return this;
5866        }
5867
5868        protected void listChildren(List<Property> children) {
5869          super.listChildren(children);
5870          children.add(new Property("identity", "id", "An internal reference to the definition of a mapping.", 0, 1, identity));
5871          children.add(new Property("language", "code", "Identifies the computable language in which mapping.map is expressed.", 0, 1, language));
5872          children.add(new Property("map", "string", "Expresses what part of the target specification corresponds to this element.", 0, 1, map));
5873          children.add(new Property("comment", "markdown", "Comments that provide information about the mapping or its use.", 0, 1, comment));
5874        }
5875
5876        @Override
5877        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5878          switch (_hash) {
5879          case -135761730: /*identity*/  return new Property("identity", "id", "An internal reference to the definition of a mapping.", 0, 1, identity);
5880          case -1613589672: /*language*/  return new Property("language", "code", "Identifies the computable language in which mapping.map is expressed.", 0, 1, language);
5881          case 107868: /*map*/  return new Property("map", "string", "Expresses what part of the target specification corresponds to this element.", 0, 1, map);
5882          case 950398559: /*comment*/  return new Property("comment", "markdown", "Comments that provide information about the mapping or its use.", 0, 1, comment);
5883          default: return super.getNamedProperty(_hash, _name, _checkValid);
5884          }
5885
5886        }
5887
5888      @Override
5889      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5890        switch (hash) {
5891        case -135761730: /*identity*/ return this.identity == null ? new Base[0] : new Base[] {this.identity}; // IdType
5892        case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // CodeType
5893        case 107868: /*map*/ return this.map == null ? new Base[0] : new Base[] {this.map}; // StringType
5894        case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // MarkdownType
5895        default: return super.getProperty(hash, name, checkValid);
5896        }
5897
5898      }
5899
5900      @Override
5901      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5902        switch (hash) {
5903        case -135761730: // identity
5904          this.identity = TypeConvertor.castToId(value); // IdType
5905          return value;
5906        case -1613589672: // language
5907          this.language = TypeConvertor.castToCode(value); // CodeType
5908          return value;
5909        case 107868: // map
5910          this.map = TypeConvertor.castToString(value); // StringType
5911          return value;
5912        case 950398559: // comment
5913          this.comment = TypeConvertor.castToMarkdown(value); // MarkdownType
5914          return value;
5915        default: return super.setProperty(hash, name, value);
5916        }
5917
5918      }
5919
5920      @Override
5921      public Base setProperty(String name, Base value) throws FHIRException {
5922        if (name.equals("identity")) {
5923          this.identity = TypeConvertor.castToId(value); // IdType
5924        } else if (name.equals("language")) {
5925          this.language = TypeConvertor.castToCode(value); // CodeType
5926        } else if (name.equals("map")) {
5927          this.map = TypeConvertor.castToString(value); // StringType
5928        } else if (name.equals("comment")) {
5929          this.comment = TypeConvertor.castToMarkdown(value); // MarkdownType
5930        } else
5931          return super.setProperty(name, value);
5932        return value;
5933      }
5934
5935  @Override
5936  public void removeChild(String name, Base value) throws FHIRException {
5937        if (name.equals("identity")) {
5938          this.identity = null;
5939        } else if (name.equals("language")) {
5940          this.language = null;
5941        } else if (name.equals("map")) {
5942          this.map = null;
5943        } else if (name.equals("comment")) {
5944          this.comment = null;
5945        } else
5946          super.removeChild(name, value);
5947        
5948      }
5949
5950      @Override
5951      public Base makeProperty(int hash, String name) throws FHIRException {
5952        switch (hash) {
5953        case -135761730:  return getIdentityElement();
5954        case -1613589672:  return getLanguageElement();
5955        case 107868:  return getMapElement();
5956        case 950398559:  return getCommentElement();
5957        default: return super.makeProperty(hash, name);
5958        }
5959
5960      }
5961
5962      @Override
5963      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5964        switch (hash) {
5965        case -135761730: /*identity*/ return new String[] {"id"};
5966        case -1613589672: /*language*/ return new String[] {"code"};
5967        case 107868: /*map*/ return new String[] {"string"};
5968        case 950398559: /*comment*/ return new String[] {"markdown"};
5969        default: return super.getTypesForProperty(hash, name);
5970        }
5971
5972      }
5973
5974      @Override
5975      public Base addChild(String name) throws FHIRException {
5976        if (name.equals("identity")) {
5977          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.mapping.identity");
5978        }
5979        else if (name.equals("language")) {
5980          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.mapping.language");
5981        }
5982        else if (name.equals("map")) {
5983          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.mapping.map");
5984        }
5985        else if (name.equals("comment")) {
5986          throw new FHIRException("Cannot call addChild on a singleton property ElementDefinition.mapping.comment");
5987        }
5988        else
5989          return super.addChild(name);
5990      }
5991
5992      public ElementDefinitionMappingComponent copy() {
5993        ElementDefinitionMappingComponent dst = new ElementDefinitionMappingComponent();
5994        copyValues(dst);
5995        return dst;
5996      }
5997
5998      public void copyValues(ElementDefinitionMappingComponent dst) {
5999        super.copyValues(dst);
6000        dst.identity = identity == null ? null : identity.copy();
6001        dst.language = language == null ? null : language.copy();
6002        dst.map = map == null ? null : map.copy();
6003        dst.comment = comment == null ? null : comment.copy();
6004      }
6005
6006      @Override
6007      public boolean equalsDeep(Base other_) {
6008        if (!super.equalsDeep(other_))
6009          return false;
6010        if (!(other_ instanceof ElementDefinitionMappingComponent))
6011          return false;
6012        ElementDefinitionMappingComponent o = (ElementDefinitionMappingComponent) other_;
6013        return compareDeep(identity, o.identity, true) && compareDeep(language, o.language, true) && compareDeep(map, o.map, true)
6014           && compareDeep(comment, o.comment, true);
6015      }
6016
6017      @Override
6018      public boolean equalsShallow(Base other_) {
6019        if (!super.equalsShallow(other_))
6020          return false;
6021        if (!(other_ instanceof ElementDefinitionMappingComponent))
6022          return false;
6023        ElementDefinitionMappingComponent o = (ElementDefinitionMappingComponent) other_;
6024        return compareValues(identity, o.identity, true) && compareValues(language, o.language, true) && compareValues(map, o.map, true)
6025           && compareValues(comment, o.comment, true);
6026      }
6027
6028      public boolean isEmpty() {
6029        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identity, language, map
6030          , comment);
6031      }
6032
6033  public String fhirType() {
6034    return "ElementDefinition.mapping";
6035
6036  }
6037
6038  }
6039
6040    /**
6041     * The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.
6042     */
6043    @Child(name = "path", type = {StringType.class}, order=0, min=1, max=1, modifier=false, summary=true)
6044    @Description(shortDefinition="Path of the element in the hierarchy of elements", formalDefinition="The path identifies the element and is expressed as a \".\"-separated list of ancestor elements, beginning with the name of the resource or extension." )
6045    protected StringType path;
6046
6047    /**
6048     * Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used.
6049     */
6050    @Child(name = "representation", type = {CodeType.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6051    @Description(shortDefinition="xmlAttr | xmlText | typeAttr | cdaText | xhtml", formalDefinition="Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used." )
6052    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/property-representation")
6053    protected List<Enumeration<PropertyRepresentation>> representation;
6054
6055    /**
6056     * The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.
6057     */
6058    @Child(name = "sliceName", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
6059    @Description(shortDefinition="Name for this particular element (in a set of slices)", formalDefinition="The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element." )
6060    protected StringType sliceName;
6061
6062    /**
6063     * If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.
6064     */
6065    @Child(name = "sliceIsConstraining", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=true)
6066    @Description(shortDefinition="If this slice definition constrains an inherited slice definition (or not)", formalDefinition="If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName." )
6067    protected BooleanType sliceIsConstraining;
6068
6069    /**
6070     * A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
6071     */
6072    @Child(name = "label", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
6073    @Description(shortDefinition="Name for element to display with or prompt for element", formalDefinition="A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form." )
6074    protected StringType label;
6075
6076    /**
6077     * A code that has the same meaning as the element in a particular terminology.
6078     */
6079    @Child(name = "code", type = {Coding.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6080    @Description(shortDefinition="Corresponding codes in terminologies", formalDefinition="A code that has the same meaning as the element in a particular terminology." )
6081    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://loinc.org/vs")
6082    protected List<Coding> code;
6083
6084    /**
6085     * Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).
6086     */
6087    @Child(name = "slicing", type = {}, order=6, min=0, max=1, modifier=false, summary=true)
6088    @Description(shortDefinition="This element is sliced - slices follow", formalDefinition="Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set)." )
6089    protected ElementDefinitionSlicingComponent slicing;
6090
6091    /**
6092     * A concise description of what this element means (e.g. for use in autogenerated summaries).
6093     */
6094    @Child(name = "short", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=true)
6095    @Description(shortDefinition="Concise definition for space-constrained presentation", formalDefinition="A concise description of what this element means (e.g. for use in autogenerated summaries)." )
6096    protected StringType short_;
6097
6098    /**
6099     * Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).
6100     */
6101    @Child(name = "definition", type = {MarkdownType.class}, order=8, min=0, max=1, modifier=false, summary=true)
6102    @Description(shortDefinition="Full formal definition as narrative text", formalDefinition="Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition)." )
6103    protected MarkdownType definition;
6104
6105    /**
6106     * Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).
6107     */
6108    @Child(name = "comment", type = {MarkdownType.class}, order=9, min=0, max=1, modifier=false, summary=true)
6109    @Description(shortDefinition="Comments about the use of this element", formalDefinition="Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment)." )
6110    protected MarkdownType comment;
6111
6112    /**
6113     * This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
6114     */
6115    @Child(name = "requirements", type = {MarkdownType.class}, order=10, min=0, max=1, modifier=false, summary=true)
6116    @Description(shortDefinition="Why this resource has been created", formalDefinition="This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element." )
6117    protected MarkdownType requirements;
6118
6119    /**
6120     * Identifies additional names by which this element might also be known.
6121     */
6122    @Child(name = "alias", type = {StringType.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6123    @Description(shortDefinition="Other names", formalDefinition="Identifies additional names by which this element might also be known." )
6124    protected List<StringType> alias;
6125
6126    /**
6127     * The minimum number of times this element SHALL appear in the instance.
6128     */
6129    @Child(name = "min", type = {UnsignedIntType.class}, order=12, min=0, max=1, modifier=false, summary=true)
6130    @Description(shortDefinition="Minimum Cardinality", formalDefinition="The minimum number of times this element SHALL appear in the instance." )
6131    protected UnsignedIntType min;
6132
6133    /**
6134     * The maximum number of times this element is permitted to appear in the instance.
6135     */
6136    @Child(name = "max", type = {StringType.class}, order=13, min=0, max=1, modifier=false, summary=true)
6137    @Description(shortDefinition="Maximum Cardinality (a number or *)", formalDefinition="The maximum number of times this element is permitted to appear in the instance." )
6138    protected StringType max;
6139
6140    /**
6141     * Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - e.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.
6142     */
6143    @Child(name = "base", type = {}, order=14, min=0, max=1, modifier=false, summary=true)
6144    @Description(shortDefinition="Base definition information for tools", formalDefinition="Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - e.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same." )
6145    protected ElementDefinitionBaseComponent base;
6146
6147    /**
6148     * Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.
6149     */
6150    @Child(name = "contentReference", type = {UriType.class}, order=15, min=0, max=1, modifier=false, summary=true)
6151    @Description(shortDefinition="Reference to definition of content for the element", formalDefinition="Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc." )
6152    protected UriType contentReference;
6153
6154    /**
6155     * The data type or resource that the value of this element is permitted to be.
6156     */
6157    @Child(name = "type", type = {}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6158    @Description(shortDefinition="Data type and Profile for this element", formalDefinition="The data type or resource that the value of this element is permitted to be." )
6159    protected List<TypeRefComponent> type;
6160
6161    /**
6162     * The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').
6163     */
6164    @Child(name = "defaultValue", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, CodeableReference.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, RatioRange.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Availability.class, ExtendedContactDetail.class, Dosage.class, Meta.class}, order=17, min=0, max=1, modifier=false, summary=true)
6165    @Description(shortDefinition="Specified value if missing from instance", formalDefinition="The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false')." )
6166    protected DataType defaultValue;
6167
6168    /**
6169     * The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').
6170     */
6171    @Child(name = "meaningWhenMissing", type = {MarkdownType.class}, order=18, min=0, max=1, modifier=false, summary=true)
6172    @Description(shortDefinition="Implicit meaning when this element is missing", formalDefinition="The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing')." )
6173    protected MarkdownType meaningWhenMissing;
6174
6175    /**
6176     * If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning.
6177     */
6178    @Child(name = "orderMeaning", type = {StringType.class}, order=19, min=0, max=1, modifier=false, summary=true)
6179    @Description(shortDefinition="What the order of the elements means", formalDefinition="If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning." )
6180    protected StringType orderMeaning;
6181
6182    /**
6183     * Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.
6184     */
6185    @Child(name = "fixed", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, CodeableReference.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, RatioRange.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Availability.class, ExtendedContactDetail.class, Dosage.class, Meta.class}, order=20, min=0, max=1, modifier=false, summary=true)
6186    @Description(shortDefinition="Value must be exactly this", formalDefinition="Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing." )
6187    protected DataType fixed;
6188
6189    /**
6190     * Specifies a value that each occurrence of the element in the instance SHALL follow - that is, any value in the pattern must be found in the instance, if the element has a value. Other additional values may be found too. This is effectively constraint by example.  
6191
6192When pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.
6193
6194When an element within a pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] must (recursively) match at least one element from the instance array.
6195
6196When pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,
6197
61981. If primitive: it must match exactly the pattern value
61992. If a complex object: it must match (recursively) the pattern value
62003. If an array: it must match (recursively) the pattern value
6201
6202If a pattern[x] is declared on a repeating element, the pattern applies to all repetitions.  If the desire is for a pattern to apply to only one element or a subset of elements, slicing must be used. See [Examples of Patterns](elementdefinition-examples.html#pattern-examples) for examples of pattern usage and the effect it will have.
6203     */
6204    @Child(name = "pattern", type = {Base64BinaryType.class, BooleanType.class, CanonicalType.class, CodeType.class, DateType.class, DateTimeType.class, DecimalType.class, IdType.class, InstantType.class, IntegerType.class, Integer64Type.class, MarkdownType.class, OidType.class, PositiveIntType.class, StringType.class, TimeType.class, UnsignedIntType.class, UriType.class, UrlType.class, UuidType.class, Address.class, Age.class, Annotation.class, Attachment.class, CodeableConcept.class, CodeableReference.class, Coding.class, ContactPoint.class, Count.class, Distance.class, Duration.class, HumanName.class, Identifier.class, Money.class, Period.class, Quantity.class, Range.class, Ratio.class, RatioRange.class, Reference.class, SampledData.class, Signature.class, Timing.class, ContactDetail.class, DataRequirement.class, Expression.class, ParameterDefinition.class, RelatedArtifact.class, TriggerDefinition.class, UsageContext.class, Availability.class, ExtendedContactDetail.class, Dosage.class, Meta.class}, order=21, min=0, max=1, modifier=false, summary=true)
6205    @Description(shortDefinition="Value must have at least these property values", formalDefinition="Specifies a value that each occurrence of the element in the instance SHALL follow - that is, any value in the pattern must be found in the instance, if the element has a value. Other additional values may be found too. This is effectively constraint by example.  \n\nWhen pattern[x] is used to constrain a primitive, it means that the value provided in the pattern[x] must match the instance value exactly.\n\nWhen an element within a pattern[x] is used to constrain an array, it means that each element provided in the pattern[x] must (recursively) match at least one element from the instance array.\n\nWhen pattern[x] is used to constrain a complex object, it means that each property in the pattern must be present in the complex object, and its value must recursively match -- i.e.,\n\n1. If primitive: it must match exactly the pattern value\n2. If a complex object: it must match (recursively) the pattern value\n3. If an array: it must match (recursively) the pattern value\n\nIf a pattern[x] is declared on a repeating element, the pattern applies to all repetitions.  If the desire is for a pattern to apply to only one element or a subset of elements, slicing must be used. See [Examples of Patterns](elementdefinition-examples.html#pattern-examples) for examples of pattern usage and the effect it will have." )
6206    protected DataType pattern;
6207
6208    /**
6209     * A sample value for this element demonstrating the type of information that would typically be found in the element.
6210     */
6211    @Child(name = "example", type = {}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6212    @Description(shortDefinition="Example value (as defined for type)", formalDefinition="A sample value for this element demonstrating the type of information that would typically be found in the element." )
6213    protected List<ElementDefinitionExampleComponent> example;
6214
6215    /**
6216     * The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.
6217     */
6218    @Child(name = "minValue", type = {DateType.class, DateTimeType.class, InstantType.class, TimeType.class, DecimalType.class, IntegerType.class, Integer64Type.class, PositiveIntType.class, UnsignedIntType.class, Quantity.class}, order=23, min=0, max=1, modifier=false, summary=true)
6219    @Description(shortDefinition="Minimum Allowed Value (for some types)", formalDefinition="The minimum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity." )
6220    protected DataType minValue;
6221
6222    /**
6223     * The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity.
6224     */
6225    @Child(name = "maxValue", type = {DateType.class, DateTimeType.class, InstantType.class, TimeType.class, DecimalType.class, IntegerType.class, Integer64Type.class, PositiveIntType.class, UnsignedIntType.class, Quantity.class}, order=24, min=0, max=1, modifier=false, summary=true)
6226    @Description(shortDefinition="Maximum Allowed Value (for some types)", formalDefinition="The maximum allowed value for the element. The value is inclusive. This is allowed for the types date, dateTime, instant, time, decimal, integer, and Quantity." )
6227    protected DataType maxValue;
6228
6229    /**
6230     * Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element. ```maxLength``` SHOULD only be used on primitive data types that have a string representation (see [http://hl7.org/fhir/StructureDefinition/structuredefinition-type-characteristics](https://build.fhir.org/ig/HL7/fhir-extensions/StructureDefinition-structuredefinition-type-characteristics.html)).
6231     */
6232    @Child(name = "maxLength", type = {IntegerType.class}, order=25, min=0, max=1, modifier=false, summary=true)
6233    @Description(shortDefinition="Max length for string type data", formalDefinition="Indicates the maximum length in characters that is permitted to be present in conformant instances and which is expected to be supported by conformant consumers that support the element. ```maxLength``` SHOULD only be used on primitive data types that have a string representation (see [http://hl7.org/fhir/StructureDefinition/structuredefinition-type-characteristics](https://build.fhir.org/ig/HL7/fhir-extensions/StructureDefinition-structuredefinition-type-characteristics.html))." )
6234    protected IntegerType maxLength;
6235
6236    /**
6237     * A reference to an invariant that may make additional statements about the cardinality or value in the instance.
6238     */
6239    @Child(name = "condition", type = {IdType.class}, order=26, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6240    @Description(shortDefinition="Reference to invariant about presence", formalDefinition="A reference to an invariant that may make additional statements about the cardinality or value in the instance." )
6241    protected List<IdType> condition;
6242
6243    /**
6244     * Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance.
6245     */
6246    @Child(name = "constraint", type = {}, order=27, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6247    @Description(shortDefinition="Condition that must evaluate to true", formalDefinition="Formal constraints such as co-occurrence and other constraints that can be computationally evaluated within the context of the instance." )
6248    protected List<ElementDefinitionConstraintComponent> constraint;
6249
6250    /**
6251     * Specifies for a primitive data type that the value of the data type cannot be replaced by an extension.
6252     */
6253    @Child(name = "mustHaveValue", type = {BooleanType.class}, order=28, min=0, max=1, modifier=false, summary=true)
6254    @Description(shortDefinition="For primitives, that a value must be present - not replaced by an extension", formalDefinition="Specifies for a primitive data type that the value of the data type cannot be replaced by an extension." )
6255    protected BooleanType mustHaveValue;
6256
6257    /**
6258     * Specifies a list of extensions that can appear in place of a primitive value.
6259     */
6260    @Child(name = "valueAlternatives", type = {CanonicalType.class}, order=29, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6261    @Description(shortDefinition="Extensions that are allowed to replace a primitive value", formalDefinition="Specifies a list of extensions that can appear in place of a primitive value." )
6262    protected List<CanonicalType> valueAlternatives;
6263
6264    /**
6265     * If true, implementations that produce or consume resources SHALL provide "support" for the element in some meaningful way. Note that this is being phased out and replaced by obligations (see below).  If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation.
6266     */
6267    @Child(name = "mustSupport", type = {BooleanType.class}, order=30, min=0, max=1, modifier=false, summary=true)
6268    @Description(shortDefinition="If the element must be supported (discouraged - see obligations)", formalDefinition="If true, implementations that produce or consume resources SHALL provide \"support\" for the element in some meaningful way. Note that this is being phased out and replaced by obligations (see below).  If false, the element may be ignored and not supported. If false, whether to populate or use the data element in any way is at the discretion of the implementation." )
6269    protected BooleanType mustSupport;
6270
6271    /**
6272     * If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system. When used on the root element in an extension definition, this indicates whether or not the extension is a modifier extension.
6273     */
6274    @Child(name = "isModifier", type = {BooleanType.class}, order=31, min=0, max=1, modifier=false, summary=true)
6275    @Description(shortDefinition="If this modifies the meaning of other elements", formalDefinition="If true, the value of this element affects the interpretation of the element or resource that contains it, and the value of the element cannot be ignored. Typically, this is used for status, negation and qualification codes. The effect of this is that the element cannot be ignored by systems: they SHALL either recognize the element and process it, and/or a pre-determination has been made that it is not relevant to their particular system. When used on the root element in an extension definition, this indicates whether or not the extension is a modifier extension." )
6276    protected BooleanType isModifier;
6277
6278    /**
6279     * Explains how that element affects the interpretation of the resource or element that contains it.
6280     */
6281    @Child(name = "isModifierReason", type = {StringType.class}, order=32, min=0, max=1, modifier=false, summary=true)
6282    @Description(shortDefinition="Reason that this element is marked as a modifier", formalDefinition="Explains how that element affects the interpretation of the resource or element that contains it." )
6283    protected StringType isModifierReason;
6284
6285    /**
6286     * Whether the element should be included if a client requests a search with the parameter _summary=true.
6287     */
6288    @Child(name = "isSummary", type = {BooleanType.class}, order=33, min=0, max=1, modifier=false, summary=true)
6289    @Description(shortDefinition="Include when _summary = true?", formalDefinition="Whether the element should be included if a client requests a search with the parameter _summary=true." )
6290    protected BooleanType isSummary;
6291
6292    /**
6293     * Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri).
6294     */
6295    @Child(name = "binding", type = {}, order=34, min=0, max=1, modifier=false, summary=true)
6296    @Description(shortDefinition="ValueSet details if this is coded", formalDefinition="Binds to a value set if this element is coded (code, Coding, CodeableConcept, Quantity), or the data types (string, uri)." )
6297    protected ElementDefinitionBindingComponent binding;
6298
6299    /**
6300     * Identifies a concept from an external specification that roughly corresponds to this element.
6301     */
6302    @Child(name = "mapping", type = {}, order=35, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6303    @Description(shortDefinition="Map element to another set of definitions", formalDefinition="Identifies a concept from an external specification that roughly corresponds to this element." )
6304    protected List<ElementDefinitionMappingComponent> mapping;
6305
6306    private static final long serialVersionUID = -1474105308L;
6307
6308  /**
6309   * Constructor
6310   */
6311    public ElementDefinition() {
6312      super();
6313    }
6314
6315  /**
6316   * Constructor
6317   */
6318    public ElementDefinition(String path) {
6319      super();
6320      this.setPath(path);
6321    }
6322
6323    /**
6324     * @return {@link #path} (The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
6325     */
6326    public StringType getPathElement() { 
6327      if (this.path == null)
6328        if (Configuration.errorOnAutoCreate())
6329          throw new Error("Attempt to auto-create ElementDefinition.path");
6330        else if (Configuration.doAutoCreate())
6331          this.path = new StringType(); // bb
6332      return this.path;
6333    }
6334
6335    public boolean hasPathElement() { 
6336      return this.path != null && !this.path.isEmpty();
6337    }
6338
6339    public boolean hasPath() { 
6340      return this.path != null && !this.path.isEmpty();
6341    }
6342
6343    /**
6344     * @param value {@link #path} (The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
6345     */
6346    public ElementDefinition setPathElement(StringType value) { 
6347      this.path = value;
6348      return this;
6349    }
6350
6351    /**
6352     * @return The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.
6353     */
6354    public String getPath() { 
6355      return this.path == null ? null : this.path.getValue();
6356    }
6357
6358    /**
6359     * @param value The path identifies the element and is expressed as a "."-separated list of ancestor elements, beginning with the name of the resource or extension.
6360     */
6361    public ElementDefinition setPath(String value) { 
6362        if (this.path == null)
6363          this.path = new StringType();
6364        this.path.setValue(value);
6365      return this;
6366    }
6367
6368    /**
6369     * @return {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used.)
6370     */
6371    public List<Enumeration<PropertyRepresentation>> getRepresentation() { 
6372      if (this.representation == null)
6373        this.representation = new ArrayList<Enumeration<PropertyRepresentation>>();
6374      return this.representation;
6375    }
6376
6377    /**
6378     * @return Returns a reference to <code>this</code> for easy method chaining
6379     */
6380    public ElementDefinition setRepresentation(List<Enumeration<PropertyRepresentation>> theRepresentation) { 
6381      this.representation = theRepresentation;
6382      return this;
6383    }
6384
6385    public boolean hasRepresentation() { 
6386      if (this.representation == null)
6387        return false;
6388      for (Enumeration<PropertyRepresentation> item : this.representation)
6389        if (!item.isEmpty())
6390          return true;
6391      return false;
6392    }
6393
6394    /**
6395     * @return {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used.)
6396     */
6397    public Enumeration<PropertyRepresentation> addRepresentationElement() {//2 
6398      Enumeration<PropertyRepresentation> t = new Enumeration<PropertyRepresentation>(new PropertyRepresentationEnumFactory());
6399      if (this.representation == null)
6400        this.representation = new ArrayList<Enumeration<PropertyRepresentation>>();
6401      this.representation.add(t);
6402      return t;
6403    }
6404
6405    /**
6406     * @param value {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used.)
6407     */
6408    public ElementDefinition addRepresentation(PropertyRepresentation value) { //1
6409      Enumeration<PropertyRepresentation> t = new Enumeration<PropertyRepresentation>(new PropertyRepresentationEnumFactory());
6410      t.setValue(value);
6411      if (this.representation == null)
6412        this.representation = new ArrayList<Enumeration<PropertyRepresentation>>();
6413      this.representation.add(t);
6414      return this;
6415    }
6416
6417    /**
6418     * @param value {@link #representation} (Codes that define how this element is represented in instances, when the deviation varies from the normal case. No extensions are allowed on elements with a representation of 'xmlAttr', no matter what FHIR serialization format is used.)
6419     */
6420    public boolean hasRepresentation(PropertyRepresentation value) { 
6421      if (this.representation == null)
6422        return false;
6423      for (Enumeration<PropertyRepresentation> v : this.representation)
6424        if (v.getValue().equals(value)) // code
6425          return true;
6426      return false;
6427    }
6428
6429    /**
6430     * @return {@link #sliceName} (The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value
6431     */
6432    public StringType getSliceNameElement() { 
6433      if (this.sliceName == null)
6434        if (Configuration.errorOnAutoCreate())
6435          throw new Error("Attempt to auto-create ElementDefinition.sliceName");
6436        else if (Configuration.doAutoCreate())
6437          this.sliceName = new StringType(); // bb
6438      return this.sliceName;
6439    }
6440
6441    public boolean hasSliceNameElement() { 
6442      return this.sliceName != null && !this.sliceName.isEmpty();
6443    }
6444
6445    public boolean hasSliceName() { 
6446      return this.sliceName != null && !this.sliceName.isEmpty();
6447    }
6448
6449    /**
6450     * @param value {@link #sliceName} (The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.). This is the underlying object with id, value and extensions. The accessor "getSliceName" gives direct access to the value
6451     */
6452    public ElementDefinition setSliceNameElement(StringType value) { 
6453      this.sliceName = value;
6454      return this;
6455    }
6456
6457    /**
6458     * @return The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.
6459     */
6460    public String getSliceName() { 
6461      return this.sliceName == null ? null : this.sliceName.getValue();
6462    }
6463
6464    /**
6465     * @param value The name of this element definition slice, when slicing is working. The name must be a token with no dots or spaces. This is a unique name referring to a specific set of constraints applied to this element, used to provide a name to different slices of the same element.
6466     */
6467    public ElementDefinition setSliceName(String value) { 
6468      if (Utilities.noString(value))
6469        this.sliceName = null;
6470      else {
6471        if (this.sliceName == null)
6472          this.sliceName = new StringType();
6473        this.sliceName.setValue(value);
6474      }
6475      return this;
6476    }
6477
6478    /**
6479     * @return {@link #sliceIsConstraining} (If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value
6480     */
6481    public BooleanType getSliceIsConstrainingElement() { 
6482      if (this.sliceIsConstraining == null)
6483        if (Configuration.errorOnAutoCreate())
6484          throw new Error("Attempt to auto-create ElementDefinition.sliceIsConstraining");
6485        else if (Configuration.doAutoCreate())
6486          this.sliceIsConstraining = new BooleanType(); // bb
6487      return this.sliceIsConstraining;
6488    }
6489
6490    public boolean hasSliceIsConstrainingElement() { 
6491      return this.sliceIsConstraining != null && !this.sliceIsConstraining.isEmpty();
6492    }
6493
6494    public boolean hasSliceIsConstraining() { 
6495      return this.sliceIsConstraining != null && !this.sliceIsConstraining.isEmpty();
6496    }
6497
6498    /**
6499     * @param value {@link #sliceIsConstraining} (If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.). This is the underlying object with id, value and extensions. The accessor "getSliceIsConstraining" gives direct access to the value
6500     */
6501    public ElementDefinition setSliceIsConstrainingElement(BooleanType value) { 
6502      this.sliceIsConstraining = value;
6503      return this;
6504    }
6505
6506    /**
6507     * @return If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.
6508     */
6509    public boolean getSliceIsConstraining() { 
6510      return this.sliceIsConstraining == null || this.sliceIsConstraining.isEmpty() ? false : this.sliceIsConstraining.getValue();
6511    }
6512
6513    /**
6514     * @param value If true, indicates that this slice definition is constraining a slice definition with the same name in an inherited profile. If false, the slice is not overriding any slice in an inherited profile. If missing, the slice might or might not be overriding a slice in an inherited profile, depending on the sliceName.
6515     */
6516    public ElementDefinition setSliceIsConstraining(boolean value) { 
6517        if (this.sliceIsConstraining == null)
6518          this.sliceIsConstraining = new BooleanType();
6519        this.sliceIsConstraining.setValue(value);
6520      return this;
6521    }
6522
6523    /**
6524     * @return {@link #label} (A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
6525     */
6526    public StringType getLabelElement() { 
6527      if (this.label == null)
6528        if (Configuration.errorOnAutoCreate())
6529          throw new Error("Attempt to auto-create ElementDefinition.label");
6530        else if (Configuration.doAutoCreate())
6531          this.label = new StringType(); // bb
6532      return this.label;
6533    }
6534
6535    public boolean hasLabelElement() { 
6536      return this.label != null && !this.label.isEmpty();
6537    }
6538
6539    public boolean hasLabel() { 
6540      return this.label != null && !this.label.isEmpty();
6541    }
6542
6543    /**
6544     * @param value {@link #label} (A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
6545     */
6546    public ElementDefinition setLabelElement(StringType value) { 
6547      this.label = value;
6548      return this;
6549    }
6550
6551    /**
6552     * @return A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
6553     */
6554    public String getLabel() { 
6555      return this.label == null ? null : this.label.getValue();
6556    }
6557
6558    /**
6559     * @param value A single preferred label which is the text to display beside the element indicating its meaning or to use to prompt for the element in a user display or form.
6560     */
6561    public ElementDefinition setLabel(String value) { 
6562      if (Utilities.noString(value))
6563        this.label = null;
6564      else {
6565        if (this.label == null)
6566          this.label = new StringType();
6567        this.label.setValue(value);
6568      }
6569      return this;
6570    }
6571
6572    /**
6573     * @return {@link #code} (A code that has the same meaning as the element in a particular terminology.)
6574     */
6575    public List<Coding> getCode() { 
6576      if (this.code == null)
6577        this.code = new ArrayList<Coding>();
6578      return this.code;
6579    }
6580
6581    /**
6582     * @return Returns a reference to <code>this</code> for easy method chaining
6583     */
6584    public ElementDefinition setCode(List<Coding> theCode) { 
6585      this.code = theCode;
6586      return this;
6587    }
6588
6589    public boolean hasCode() { 
6590      if (this.code == null)
6591        return false;
6592      for (Coding item : this.code)
6593        if (!item.isEmpty())
6594          return true;
6595      return false;
6596    }
6597
6598    public Coding addCode() { //3
6599      Coding t = new Coding();
6600      if (this.code == null)
6601        this.code = new ArrayList<Coding>();
6602      this.code.add(t);
6603      return t;
6604    }
6605
6606    public ElementDefinition addCode(Coding t) { //3
6607      if (t == null)
6608        return this;
6609      if (this.code == null)
6610        this.code = new ArrayList<Coding>();
6611      this.code.add(t);
6612      return this;
6613    }
6614
6615    /**
6616     * @return The first repetition of repeating field {@link #code}, creating it if it does not already exist {3}
6617     */
6618    public Coding getCodeFirstRep() { 
6619      if (getCode().isEmpty()) {
6620        addCode();
6621      }
6622      return getCode().get(0);
6623    }
6624
6625    /**
6626     * @return {@link #slicing} (Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).)
6627     */
6628    public ElementDefinitionSlicingComponent getSlicing() { 
6629      if (this.slicing == null)
6630        if (Configuration.errorOnAutoCreate())
6631          throw new Error("Attempt to auto-create ElementDefinition.slicing");
6632        else if (Configuration.doAutoCreate())
6633          this.slicing = new ElementDefinitionSlicingComponent(); // cc
6634      return this.slicing;
6635    }
6636
6637    public boolean hasSlicing() { 
6638      return this.slicing != null && !this.slicing.isEmpty();
6639    }
6640
6641    /**
6642     * @param value {@link #slicing} (Indicates that the element is sliced into a set of alternative definitions (i.e. in a structure definition, there are multiple different constraints on a single element in the base resource). Slicing can be used in any resource that has cardinality ..* on the base resource, or any resource with a choice of types. The set of slices is any elements that come after this in the element sequence that have the same path, until a shorter path occurs (the shorter path terminates the set).)
6643     */
6644    public ElementDefinition setSlicing(ElementDefinitionSlicingComponent value) { 
6645      this.slicing = value;
6646      return this;
6647    }
6648
6649    /**
6650     * @return {@link #short_} (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value
6651     */
6652    public StringType getShortElement() { 
6653      if (this.short_ == null)
6654        if (Configuration.errorOnAutoCreate())
6655          throw new Error("Attempt to auto-create ElementDefinition.short_");
6656        else if (Configuration.doAutoCreate())
6657          this.short_ = new StringType(); // bb
6658      return this.short_;
6659    }
6660
6661    public boolean hasShortElement() { 
6662      return this.short_ != null && !this.short_.isEmpty();
6663    }
6664
6665    public boolean hasShort() { 
6666      return this.short_ != null && !this.short_.isEmpty();
6667    }
6668
6669    /**
6670     * @param value {@link #short_} (A concise description of what this element means (e.g. for use in autogenerated summaries).). This is the underlying object with id, value and extensions. The accessor "getShort" gives direct access to the value
6671     */
6672    public ElementDefinition setShortElement(StringType value) { 
6673      this.short_ = value;
6674      return this;
6675    }
6676
6677    /**
6678     * @return A concise description of what this element means (e.g. for use in autogenerated summaries).
6679     */
6680    public String getShort() { 
6681      return this.short_ == null ? null : this.short_.getValue();
6682    }
6683
6684    /**
6685     * @param value A concise description of what this element means (e.g. for use in autogenerated summaries).
6686     */
6687    public ElementDefinition setShort(String value) { 
6688      if (Utilities.noString(value))
6689        this.short_ = null;
6690      else {
6691        if (this.short_ == null)
6692          this.short_ = new StringType();
6693        this.short_.setValue(value);
6694      }
6695      return this;
6696    }
6697
6698    /**
6699     * @return {@link #definition} (Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
6700     */
6701    public MarkdownType getDefinitionElement() { 
6702      if (this.definition == null)
6703        if (Configuration.errorOnAutoCreate())
6704          throw new Error("Attempt to auto-create ElementDefinition.definition");
6705        else if (Configuration.doAutoCreate())
6706          this.definition = new MarkdownType(); // bb
6707      return this.definition;
6708    }
6709
6710    public boolean hasDefinitionElement() { 
6711      return this.definition != null && !this.definition.isEmpty();
6712    }
6713
6714    public boolean hasDefinition() { 
6715      return this.definition != null && !this.definition.isEmpty();
6716    }
6717
6718    /**
6719     * @param value {@link #definition} (Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
6720     */
6721    public ElementDefinition setDefinitionElement(MarkdownType value) { 
6722      this.definition = value;
6723      return this;
6724    }
6725
6726    /**
6727     * @return Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).
6728     */
6729    public String getDefinition() { 
6730      return this.definition == null ? null : this.definition.getValue();
6731    }
6732
6733    /**
6734     * @param value Provides a complete explanation of the meaning of the data element for human readability.  For the case of elements derived from existing elements (e.g. constraints), the definition SHALL be consistent with the base definition, but convey the meaning of the element in the particular context of use of the resource. (Note: The text you are reading is specified in ElementDefinition.definition).
6735     */
6736    public ElementDefinition setDefinition(String value) { 
6737      if (Utilities.noString(value))
6738        this.definition = null;
6739      else {
6740        if (this.definition == null)
6741          this.definition = new MarkdownType();
6742        this.definition.setValue(value);
6743      }
6744      return this;
6745    }
6746
6747    /**
6748     * @return {@link #comment} (Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
6749     */
6750    public MarkdownType getCommentElement() { 
6751      if (this.comment == null)
6752        if (Configuration.errorOnAutoCreate())
6753          throw new Error("Attempt to auto-create ElementDefinition.comment");
6754        else if (Configuration.doAutoCreate())
6755          this.comment = new MarkdownType(); // bb
6756      return this.comment;
6757    }
6758
6759    public boolean hasCommentElement() { 
6760      return this.comment != null && !this.comment.isEmpty();
6761    }
6762
6763    public boolean hasComment() { 
6764      return this.comment != null && !this.comment.isEmpty();
6765    }
6766
6767    /**
6768     * @param value {@link #comment} (Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
6769     */
6770    public ElementDefinition setCommentElement(MarkdownType value) { 
6771      this.comment = value;
6772      return this;
6773    }
6774
6775    /**
6776     * @return Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).
6777     */
6778    public String getComment() { 
6779      return this.comment == null ? null : this.comment.getValue();
6780    }
6781
6782    /**
6783     * @param value Explanatory notes and implementation guidance about the data element, including notes about how to use the data properly, exceptions to proper use, etc. (Note: The text you are reading is specified in ElementDefinition.comment).
6784     */
6785    public ElementDefinition setComment(String value) { 
6786      if (Utilities.noString(value))
6787        this.comment = null;
6788      else {
6789        if (this.comment == null)
6790          this.comment = new MarkdownType();
6791        this.comment.setValue(value);
6792      }
6793      return this;
6794    }
6795
6796    /**
6797     * @return {@link #requirements} (This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
6798     */
6799    public MarkdownType getRequirementsElement() { 
6800      if (this.requirements == null)
6801        if (Configuration.errorOnAutoCreate())
6802          throw new Error("Attempt to auto-create ElementDefinition.requirements");
6803        else if (Configuration.doAutoCreate())
6804          this.requirements = new MarkdownType(); // bb
6805      return this.requirements;
6806    }
6807
6808    public boolean hasRequirementsElement() { 
6809      return this.requirements != null && !this.requirements.isEmpty();
6810    }
6811
6812    public boolean hasRequirements() { 
6813      return this.requirements != null && !this.requirements.isEmpty();
6814    }
6815
6816    /**
6817     * @param value {@link #requirements} (This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.). This is the underlying object with id, value and extensions. The accessor "getRequirements" gives direct access to the value
6818     */
6819    public ElementDefinition setRequirementsElement(MarkdownType value) { 
6820      this.requirements = value;
6821      return this;
6822    }
6823
6824    /**
6825     * @return This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
6826     */
6827    public String getRequirements() { 
6828      return this.requirements == null ? null : this.requirements.getValue();
6829    }
6830
6831    /**
6832     * @param value This element is for traceability of why the element was created and why the constraints exist as they do. This may be used to point to source materials or specifications that drove the structure of this element.
6833     */
6834    public ElementDefinition setRequirements(String value) { 
6835      if (Utilities.noString(value))
6836        this.requirements = null;
6837      else {
6838        if (this.requirements == null)
6839          this.requirements = new MarkdownType();
6840        this.requirements.setValue(value);
6841      }
6842      return this;
6843    }
6844
6845    /**
6846     * @return {@link #alias} (Identifies additional names by which this element might also be known.)
6847     */
6848    public List<StringType> getAlias() { 
6849      if (this.alias == null)
6850        this.alias = new ArrayList<StringType>();
6851      return this.alias;
6852    }
6853
6854    /**
6855     * @return Returns a reference to <code>this</code> for easy method chaining
6856     */
6857    public ElementDefinition setAlias(List<StringType> theAlias) { 
6858      this.alias = theAlias;
6859      return this;
6860    }
6861
6862    public boolean hasAlias() { 
6863      if (this.alias == null)
6864        return false;
6865      for (StringType item : this.alias)
6866        if (!item.isEmpty())
6867          return true;
6868      return false;
6869    }
6870
6871    /**
6872     * @return {@link #alias} (Identifies additional names by which this element might also be known.)
6873     */
6874    public StringType addAliasElement() {//2 
6875      StringType t = new StringType();
6876      if (this.alias == null)
6877        this.alias = new ArrayList<StringType>();
6878      this.alias.add(t);
6879      return t;
6880    }
6881
6882    /**
6883     * @param value {@link #alias} (Identifies additional names by which this element might also be known.)
6884     */
6885    public ElementDefinition addAlias(String value) { //1
6886      StringType t = new StringType();
6887      t.setValue(value);
6888      if (this.alias == null)
6889        this.alias = new ArrayList<StringType>();
6890      this.alias.add(t);
6891      return this;
6892    }
6893
6894    /**
6895     * @param value {@link #alias} (Identifies additional names by which this element might also be known.)
6896     */
6897    public boolean hasAlias(String value) { 
6898      if (this.alias == null)
6899        return false;
6900      for (StringType v : this.alias)
6901        if (v.getValue().equals(value)) // string
6902          return true;
6903      return false;
6904    }
6905
6906    /**
6907     * @return {@link #min} (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
6908     */
6909    public UnsignedIntType getMinElement() { 
6910      if (this.min == null)
6911        if (Configuration.errorOnAutoCreate())
6912          throw new Error("Attempt to auto-create ElementDefinition.min");
6913        else if (Configuration.doAutoCreate())
6914          this.min = new UnsignedIntType(); // bb
6915      return this.min;
6916    }
6917
6918    public boolean hasMinElement() { 
6919      return this.min != null && !this.min.isEmpty();
6920    }
6921
6922    public boolean hasMin() { 
6923      return this.min != null && !this.min.isEmpty();
6924    }
6925
6926    /**
6927     * @param value {@link #min} (The minimum number of times this element SHALL appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
6928     */
6929    public ElementDefinition setMinElement(UnsignedIntType value) { 
6930      this.min = value;
6931      return this;
6932    }
6933
6934    /**
6935     * @return The minimum number of times this element SHALL appear in the instance.
6936     */
6937    public int getMin() { 
6938      return this.min == null || this.min.isEmpty() ? 0 : this.min.getValue();
6939    }
6940
6941    /**
6942     * @param value The minimum number of times this element SHALL appear in the instance.
6943     */
6944    public ElementDefinition setMin(int value) { 
6945        if (this.min == null)
6946          this.min = new UnsignedIntType();
6947        this.min.setValue(value);
6948      return this;
6949    }
6950
6951    /**
6952     * @return {@link #max} (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
6953     */
6954    public StringType getMaxElement() { 
6955      if (this.max == null)
6956        if (Configuration.errorOnAutoCreate())
6957          throw new Error("Attempt to auto-create ElementDefinition.max");
6958        else if (Configuration.doAutoCreate())
6959          this.max = new StringType(); // bb
6960      return this.max;
6961    }
6962
6963    public boolean hasMaxElement() { 
6964      return this.max != null && !this.max.isEmpty();
6965    }
6966
6967    public boolean hasMax() { 
6968      return this.max != null && !this.max.isEmpty();
6969    }
6970
6971    /**
6972     * @param value {@link #max} (The maximum number of times this element is permitted to appear in the instance.). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
6973     */
6974    public ElementDefinition setMaxElement(StringType value) { 
6975      this.max = value;
6976      return this;
6977    }
6978
6979    /**
6980     * @return The maximum number of times this element is permitted to appear in the instance.
6981     */
6982    public String getMax() { 
6983      return this.max == null ? null : this.max.getValue();
6984    }
6985
6986    /**
6987     * @param value The maximum number of times this element is permitted to appear in the instance.
6988     */
6989    public ElementDefinition setMax(String value) { 
6990      if (Utilities.noString(value))
6991        this.max = null;
6992      else {
6993        if (this.max == null)
6994          this.max = new StringType();
6995        this.max.setValue(value);
6996      }
6997      return this;
6998    }
6999
7000    /**
7001     * @return {@link #base} (Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - e.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.)
7002     */
7003    public ElementDefinitionBaseComponent getBase() { 
7004      if (this.base == null)
7005        if (Configuration.errorOnAutoCreate())
7006          throw new Error("Attempt to auto-create ElementDefinition.base");
7007        else if (Configuration.doAutoCreate())
7008          this.base = new ElementDefinitionBaseComponent(); // cc
7009      return this.base;
7010    }
7011
7012    public boolean hasBase() { 
7013      return this.base != null && !this.base.isEmpty();
7014    }
7015
7016    /**
7017     * @param value {@link #base} (Information about the base definition of the element, provided to make it unnecessary for tools to trace the deviation of the element through the derived and related profiles. When the element definition is not the original definition of an element - e.g. either in a constraint on another type, or for elements from a super type in a snap shot - then the information in provided in the element definition may be different to the base definition. On the original definition of the element, it will be same.)
7018     */
7019    public ElementDefinition setBase(ElementDefinitionBaseComponent value) { 
7020      this.base = value;
7021      return this;
7022    }
7023
7024    /**
7025     * @return {@link #contentReference} (Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value
7026     */
7027    public UriType getContentReferenceElement() { 
7028      if (this.contentReference == null)
7029        if (Configuration.errorOnAutoCreate())
7030          throw new Error("Attempt to auto-create ElementDefinition.contentReference");
7031        else if (Configuration.doAutoCreate())
7032          this.contentReference = new UriType(); // bb
7033      return this.contentReference;
7034    }
7035
7036    public boolean hasContentReferenceElement() { 
7037      return this.contentReference != null && !this.contentReference.isEmpty();
7038    }
7039
7040    public boolean hasContentReference() { 
7041      return this.contentReference != null && !this.contentReference.isEmpty();
7042    }
7043
7044    /**
7045     * @param value {@link #contentReference} (Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.). This is the underlying object with id, value and extensions. The accessor "getContentReference" gives direct access to the value
7046     */
7047    public ElementDefinition setContentReferenceElement(UriType value) { 
7048      this.contentReference = value;
7049      return this;
7050    }
7051
7052    /**
7053     * @return Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.
7054     */
7055    public String getContentReference() { 
7056      return this.contentReference == null ? null : this.contentReference.getValue();
7057    }
7058
7059    /**
7060     * @param value Identifies an element defined elsewhere in the definition whose content rules should be applied to the current element. ContentReferences bring across all the rules that are in the ElementDefinition for the element, including definitions, cardinality constraints, bindings, invariants etc.
7061     */
7062    public ElementDefinition setContentReference(String value) { 
7063      if (Utilities.noString(value))
7064        this.contentReference = null;
7065      else {
7066        if (this.contentReference == null)
7067          this.contentReference = new UriType();
7068        this.contentReference.setValue(value);
7069      }
7070      return this;
7071    }
7072
7073    /**
7074     * @return {@link #type} (The data type or resource that the value of this element is permitted to be.)
7075     */
7076    public List<TypeRefComponent> getType() { 
7077      if (this.type == null)
7078        this.type = new ArrayList<TypeRefComponent>();
7079      return this.type;
7080    }
7081
7082    /**
7083     * @return Returns a reference to <code>this</code> for easy method chaining
7084     */
7085    public ElementDefinition setType(List<TypeRefComponent> theType) { 
7086      this.type = theType;
7087      return this;
7088    }
7089
7090    public boolean hasType() { 
7091      if (this.type == null)
7092        return false;
7093      for (TypeRefComponent item : this.type)
7094        if (!item.isEmpty())
7095          return true;
7096      return false;
7097    }
7098
7099    public TypeRefComponent addType() { //3
7100      TypeRefComponent t = new TypeRefComponent();
7101      if (this.type == null)
7102        this.type = new ArrayList<TypeRefComponent>();
7103      this.type.add(t);
7104      return t;
7105    }
7106
7107    public ElementDefinition addType(TypeRefComponent t) { //3
7108      if (t == null)
7109        return this;
7110      if (this.type == null)
7111        this.type = new ArrayList<TypeRefComponent>();
7112      this.type.add(t);
7113      return this;
7114    }
7115
7116    /**
7117     * @return The first repetition of repeating field {@link #type}, creating it if it does not already exist {3}
7118     */
7119    public TypeRefComponent getTypeFirstRep() { 
7120      if (getType().isEmpty()) {
7121        addType();
7122      }
7123      return getType().get(0);
7124    }
7125
7126    /**
7127     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7128     */
7129    public DataType getDefaultValue() { 
7130      return this.defaultValue;
7131    }
7132
7133    /**
7134     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7135     */
7136    public Base64BinaryType getDefaultValueBase64BinaryType() throws FHIRException { 
7137      if (this.defaultValue == null)
7138        this.defaultValue = new Base64BinaryType();
7139      if (!(this.defaultValue instanceof Base64BinaryType))
7140        throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7141      return (Base64BinaryType) this.defaultValue;
7142    }
7143
7144    public boolean hasDefaultValueBase64BinaryType() { 
7145      return this != null && this.defaultValue instanceof Base64BinaryType;
7146    }
7147
7148    /**
7149     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7150     */
7151    public BooleanType getDefaultValueBooleanType() throws FHIRException { 
7152      if (this.defaultValue == null)
7153        this.defaultValue = new BooleanType();
7154      if (!(this.defaultValue instanceof BooleanType))
7155        throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7156      return (BooleanType) this.defaultValue;
7157    }
7158
7159    public boolean hasDefaultValueBooleanType() { 
7160      return this != null && this.defaultValue instanceof BooleanType;
7161    }
7162
7163    /**
7164     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7165     */
7166    public CanonicalType getDefaultValueCanonicalType() throws FHIRException { 
7167      if (this.defaultValue == null)
7168        this.defaultValue = new CanonicalType();
7169      if (!(this.defaultValue instanceof CanonicalType))
7170        throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7171      return (CanonicalType) this.defaultValue;
7172    }
7173
7174    public boolean hasDefaultValueCanonicalType() { 
7175      return this != null && this.defaultValue instanceof CanonicalType;
7176    }
7177
7178    /**
7179     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7180     */
7181    public CodeType getDefaultValueCodeType() throws FHIRException { 
7182      if (this.defaultValue == null)
7183        this.defaultValue = new CodeType();
7184      if (!(this.defaultValue instanceof CodeType))
7185        throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7186      return (CodeType) this.defaultValue;
7187    }
7188
7189    public boolean hasDefaultValueCodeType() { 
7190      return this != null && this.defaultValue instanceof CodeType;
7191    }
7192
7193    /**
7194     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7195     */
7196    public DateType getDefaultValueDateType() throws FHIRException { 
7197      if (this.defaultValue == null)
7198        this.defaultValue = new DateType();
7199      if (!(this.defaultValue instanceof DateType))
7200        throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7201      return (DateType) this.defaultValue;
7202    }
7203
7204    public boolean hasDefaultValueDateType() { 
7205      return this != null && this.defaultValue instanceof DateType;
7206    }
7207
7208    /**
7209     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7210     */
7211    public DateTimeType getDefaultValueDateTimeType() throws FHIRException { 
7212      if (this.defaultValue == null)
7213        this.defaultValue = new DateTimeType();
7214      if (!(this.defaultValue instanceof DateTimeType))
7215        throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7216      return (DateTimeType) this.defaultValue;
7217    }
7218
7219    public boolean hasDefaultValueDateTimeType() { 
7220      return this != null && this.defaultValue instanceof DateTimeType;
7221    }
7222
7223    /**
7224     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7225     */
7226    public DecimalType getDefaultValueDecimalType() throws FHIRException { 
7227      if (this.defaultValue == null)
7228        this.defaultValue = new DecimalType();
7229      if (!(this.defaultValue instanceof DecimalType))
7230        throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7231      return (DecimalType) this.defaultValue;
7232    }
7233
7234    public boolean hasDefaultValueDecimalType() { 
7235      return this != null && this.defaultValue instanceof DecimalType;
7236    }
7237
7238    /**
7239     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7240     */
7241    public IdType getDefaultValueIdType() throws FHIRException { 
7242      if (this.defaultValue == null)
7243        this.defaultValue = new IdType();
7244      if (!(this.defaultValue instanceof IdType))
7245        throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7246      return (IdType) this.defaultValue;
7247    }
7248
7249    public boolean hasDefaultValueIdType() { 
7250      return this != null && this.defaultValue instanceof IdType;
7251    }
7252
7253    /**
7254     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7255     */
7256    public InstantType getDefaultValueInstantType() throws FHIRException { 
7257      if (this.defaultValue == null)
7258        this.defaultValue = new InstantType();
7259      if (!(this.defaultValue instanceof InstantType))
7260        throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7261      return (InstantType) this.defaultValue;
7262    }
7263
7264    public boolean hasDefaultValueInstantType() { 
7265      return this != null && this.defaultValue instanceof InstantType;
7266    }
7267
7268    /**
7269     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7270     */
7271    public IntegerType getDefaultValueIntegerType() throws FHIRException { 
7272      if (this.defaultValue == null)
7273        this.defaultValue = new IntegerType();
7274      if (!(this.defaultValue instanceof IntegerType))
7275        throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7276      return (IntegerType) this.defaultValue;
7277    }
7278
7279    public boolean hasDefaultValueIntegerType() { 
7280      return this != null && this.defaultValue instanceof IntegerType;
7281    }
7282
7283    /**
7284     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7285     */
7286    public Integer64Type getDefaultValueInteger64Type() throws FHIRException { 
7287      if (this.defaultValue == null)
7288        this.defaultValue = new Integer64Type();
7289      if (!(this.defaultValue instanceof Integer64Type))
7290        throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7291      return (Integer64Type) this.defaultValue;
7292    }
7293
7294    public boolean hasDefaultValueInteger64Type() { 
7295      return this != null && this.defaultValue instanceof Integer64Type;
7296    }
7297
7298    /**
7299     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7300     */
7301    public MarkdownType getDefaultValueMarkdownType() throws FHIRException { 
7302      if (this.defaultValue == null)
7303        this.defaultValue = new MarkdownType();
7304      if (!(this.defaultValue instanceof MarkdownType))
7305        throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7306      return (MarkdownType) this.defaultValue;
7307    }
7308
7309    public boolean hasDefaultValueMarkdownType() { 
7310      return this != null && this.defaultValue instanceof MarkdownType;
7311    }
7312
7313    /**
7314     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7315     */
7316    public OidType getDefaultValueOidType() throws FHIRException { 
7317      if (this.defaultValue == null)
7318        this.defaultValue = new OidType();
7319      if (!(this.defaultValue instanceof OidType))
7320        throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7321      return (OidType) this.defaultValue;
7322    }
7323
7324    public boolean hasDefaultValueOidType() { 
7325      return this != null && this.defaultValue instanceof OidType;
7326    }
7327
7328    /**
7329     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7330     */
7331    public PositiveIntType getDefaultValuePositiveIntType() throws FHIRException { 
7332      if (this.defaultValue == null)
7333        this.defaultValue = new PositiveIntType();
7334      if (!(this.defaultValue instanceof PositiveIntType))
7335        throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7336      return (PositiveIntType) this.defaultValue;
7337    }
7338
7339    public boolean hasDefaultValuePositiveIntType() { 
7340      return this != null && this.defaultValue instanceof PositiveIntType;
7341    }
7342
7343    /**
7344     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7345     */
7346    public StringType getDefaultValueStringType() throws FHIRException { 
7347      if (this.defaultValue == null)
7348        this.defaultValue = new StringType();
7349      if (!(this.defaultValue instanceof StringType))
7350        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7351      return (StringType) this.defaultValue;
7352    }
7353
7354    public boolean hasDefaultValueStringType() { 
7355      return this != null && this.defaultValue instanceof StringType;
7356    }
7357
7358    /**
7359     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7360     */
7361    public TimeType getDefaultValueTimeType() throws FHIRException { 
7362      if (this.defaultValue == null)
7363        this.defaultValue = new TimeType();
7364      if (!(this.defaultValue instanceof TimeType))
7365        throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7366      return (TimeType) this.defaultValue;
7367    }
7368
7369    public boolean hasDefaultValueTimeType() { 
7370      return this != null && this.defaultValue instanceof TimeType;
7371    }
7372
7373    /**
7374     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7375     */
7376    public UnsignedIntType getDefaultValueUnsignedIntType() throws FHIRException { 
7377      if (this.defaultValue == null)
7378        this.defaultValue = new UnsignedIntType();
7379      if (!(this.defaultValue instanceof UnsignedIntType))
7380        throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7381      return (UnsignedIntType) this.defaultValue;
7382    }
7383
7384    public boolean hasDefaultValueUnsignedIntType() { 
7385      return this != null && this.defaultValue instanceof UnsignedIntType;
7386    }
7387
7388    /**
7389     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7390     */
7391    public UriType getDefaultValueUriType() throws FHIRException { 
7392      if (this.defaultValue == null)
7393        this.defaultValue = new UriType();
7394      if (!(this.defaultValue instanceof UriType))
7395        throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7396      return (UriType) this.defaultValue;
7397    }
7398
7399    public boolean hasDefaultValueUriType() { 
7400      return this != null && this.defaultValue instanceof UriType;
7401    }
7402
7403    /**
7404     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7405     */
7406    public UrlType getDefaultValueUrlType() throws FHIRException { 
7407      if (this.defaultValue == null)
7408        this.defaultValue = new UrlType();
7409      if (!(this.defaultValue instanceof UrlType))
7410        throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7411      return (UrlType) this.defaultValue;
7412    }
7413
7414    public boolean hasDefaultValueUrlType() { 
7415      return this != null && this.defaultValue instanceof UrlType;
7416    }
7417
7418    /**
7419     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7420     */
7421    public UuidType getDefaultValueUuidType() throws FHIRException { 
7422      if (this.defaultValue == null)
7423        this.defaultValue = new UuidType();
7424      if (!(this.defaultValue instanceof UuidType))
7425        throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7426      return (UuidType) this.defaultValue;
7427    }
7428
7429    public boolean hasDefaultValueUuidType() { 
7430      return this != null && this.defaultValue instanceof UuidType;
7431    }
7432
7433    /**
7434     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7435     */
7436    public Address getDefaultValueAddress() throws FHIRException { 
7437      if (this.defaultValue == null)
7438        this.defaultValue = new Address();
7439      if (!(this.defaultValue instanceof Address))
7440        throw new FHIRException("Type mismatch: the type Address was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7441      return (Address) this.defaultValue;
7442    }
7443
7444    public boolean hasDefaultValueAddress() { 
7445      return this != null && this.defaultValue instanceof Address;
7446    }
7447
7448    /**
7449     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7450     */
7451    public Age getDefaultValueAge() throws FHIRException { 
7452      if (this.defaultValue == null)
7453        this.defaultValue = new Age();
7454      if (!(this.defaultValue instanceof Age))
7455        throw new FHIRException("Type mismatch: the type Age was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7456      return (Age) this.defaultValue;
7457    }
7458
7459    public boolean hasDefaultValueAge() { 
7460      return this != null && this.defaultValue instanceof Age;
7461    }
7462
7463    /**
7464     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7465     */
7466    public Annotation getDefaultValueAnnotation() throws FHIRException { 
7467      if (this.defaultValue == null)
7468        this.defaultValue = new Annotation();
7469      if (!(this.defaultValue instanceof Annotation))
7470        throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7471      return (Annotation) this.defaultValue;
7472    }
7473
7474    public boolean hasDefaultValueAnnotation() { 
7475      return this != null && this.defaultValue instanceof Annotation;
7476    }
7477
7478    /**
7479     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7480     */
7481    public Attachment getDefaultValueAttachment() throws FHIRException { 
7482      if (this.defaultValue == null)
7483        this.defaultValue = new Attachment();
7484      if (!(this.defaultValue instanceof Attachment))
7485        throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7486      return (Attachment) this.defaultValue;
7487    }
7488
7489    public boolean hasDefaultValueAttachment() { 
7490      return this != null && this.defaultValue instanceof Attachment;
7491    }
7492
7493    /**
7494     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7495     */
7496    public CodeableConcept getDefaultValueCodeableConcept() throws FHIRException { 
7497      if (this.defaultValue == null)
7498        this.defaultValue = new CodeableConcept();
7499      if (!(this.defaultValue instanceof CodeableConcept))
7500        throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7501      return (CodeableConcept) this.defaultValue;
7502    }
7503
7504    public boolean hasDefaultValueCodeableConcept() { 
7505      return this != null && this.defaultValue instanceof CodeableConcept;
7506    }
7507
7508    /**
7509     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7510     */
7511    public CodeableReference getDefaultValueCodeableReference() throws FHIRException { 
7512      if (this.defaultValue == null)
7513        this.defaultValue = new CodeableReference();
7514      if (!(this.defaultValue instanceof CodeableReference))
7515        throw new FHIRException("Type mismatch: the type CodeableReference was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7516      return (CodeableReference) this.defaultValue;
7517    }
7518
7519    public boolean hasDefaultValueCodeableReference() { 
7520      return this != null && this.defaultValue instanceof CodeableReference;
7521    }
7522
7523    /**
7524     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7525     */
7526    public Coding getDefaultValueCoding() throws FHIRException { 
7527      if (this.defaultValue == null)
7528        this.defaultValue = new Coding();
7529      if (!(this.defaultValue instanceof Coding))
7530        throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7531      return (Coding) this.defaultValue;
7532    }
7533
7534    public boolean hasDefaultValueCoding() { 
7535      return this != null && this.defaultValue instanceof Coding;
7536    }
7537
7538    /**
7539     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7540     */
7541    public ContactPoint getDefaultValueContactPoint() throws FHIRException { 
7542      if (this.defaultValue == null)
7543        this.defaultValue = new ContactPoint();
7544      if (!(this.defaultValue instanceof ContactPoint))
7545        throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7546      return (ContactPoint) this.defaultValue;
7547    }
7548
7549    public boolean hasDefaultValueContactPoint() { 
7550      return this != null && this.defaultValue instanceof ContactPoint;
7551    }
7552
7553    /**
7554     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7555     */
7556    public Count getDefaultValueCount() throws FHIRException { 
7557      if (this.defaultValue == null)
7558        this.defaultValue = new Count();
7559      if (!(this.defaultValue instanceof Count))
7560        throw new FHIRException("Type mismatch: the type Count was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7561      return (Count) this.defaultValue;
7562    }
7563
7564    public boolean hasDefaultValueCount() { 
7565      return this != null && this.defaultValue instanceof Count;
7566    }
7567
7568    /**
7569     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7570     */
7571    public Distance getDefaultValueDistance() throws FHIRException { 
7572      if (this.defaultValue == null)
7573        this.defaultValue = new Distance();
7574      if (!(this.defaultValue instanceof Distance))
7575        throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7576      return (Distance) this.defaultValue;
7577    }
7578
7579    public boolean hasDefaultValueDistance() { 
7580      return this != null && this.defaultValue instanceof Distance;
7581    }
7582
7583    /**
7584     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7585     */
7586    public Duration getDefaultValueDuration() throws FHIRException { 
7587      if (this.defaultValue == null)
7588        this.defaultValue = new Duration();
7589      if (!(this.defaultValue instanceof Duration))
7590        throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7591      return (Duration) this.defaultValue;
7592    }
7593
7594    public boolean hasDefaultValueDuration() { 
7595      return this != null && this.defaultValue instanceof Duration;
7596    }
7597
7598    /**
7599     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7600     */
7601    public HumanName getDefaultValueHumanName() throws FHIRException { 
7602      if (this.defaultValue == null)
7603        this.defaultValue = new HumanName();
7604      if (!(this.defaultValue instanceof HumanName))
7605        throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7606      return (HumanName) this.defaultValue;
7607    }
7608
7609    public boolean hasDefaultValueHumanName() { 
7610      return this != null && this.defaultValue instanceof HumanName;
7611    }
7612
7613    /**
7614     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7615     */
7616    public Identifier getDefaultValueIdentifier() throws FHIRException { 
7617      if (this.defaultValue == null)
7618        this.defaultValue = new Identifier();
7619      if (!(this.defaultValue instanceof Identifier))
7620        throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7621      return (Identifier) this.defaultValue;
7622    }
7623
7624    public boolean hasDefaultValueIdentifier() { 
7625      return this != null && this.defaultValue instanceof Identifier;
7626    }
7627
7628    /**
7629     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7630     */
7631    public Money getDefaultValueMoney() throws FHIRException { 
7632      if (this.defaultValue == null)
7633        this.defaultValue = new Money();
7634      if (!(this.defaultValue instanceof Money))
7635        throw new FHIRException("Type mismatch: the type Money was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7636      return (Money) this.defaultValue;
7637    }
7638
7639    public boolean hasDefaultValueMoney() { 
7640      return this != null && this.defaultValue instanceof Money;
7641    }
7642
7643    /**
7644     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7645     */
7646    public Period getDefaultValuePeriod() throws FHIRException { 
7647      if (this.defaultValue == null)
7648        this.defaultValue = new Period();
7649      if (!(this.defaultValue instanceof Period))
7650        throw new FHIRException("Type mismatch: the type Period was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7651      return (Period) this.defaultValue;
7652    }
7653
7654    public boolean hasDefaultValuePeriod() { 
7655      return this != null && this.defaultValue instanceof Period;
7656    }
7657
7658    /**
7659     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7660     */
7661    public Quantity getDefaultValueQuantity() throws FHIRException { 
7662      if (this.defaultValue == null)
7663        this.defaultValue = new Quantity();
7664      if (!(this.defaultValue instanceof Quantity))
7665        throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7666      return (Quantity) this.defaultValue;
7667    }
7668
7669    public boolean hasDefaultValueQuantity() { 
7670      return this != null && this.defaultValue instanceof Quantity;
7671    }
7672
7673    /**
7674     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7675     */
7676    public Range getDefaultValueRange() throws FHIRException { 
7677      if (this.defaultValue == null)
7678        this.defaultValue = new Range();
7679      if (!(this.defaultValue instanceof Range))
7680        throw new FHIRException("Type mismatch: the type Range was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7681      return (Range) this.defaultValue;
7682    }
7683
7684    public boolean hasDefaultValueRange() { 
7685      return this != null && this.defaultValue instanceof Range;
7686    }
7687
7688    /**
7689     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7690     */
7691    public Ratio getDefaultValueRatio() throws FHIRException { 
7692      if (this.defaultValue == null)
7693        this.defaultValue = new Ratio();
7694      if (!(this.defaultValue instanceof Ratio))
7695        throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7696      return (Ratio) this.defaultValue;
7697    }
7698
7699    public boolean hasDefaultValueRatio() { 
7700      return this != null && this.defaultValue instanceof Ratio;
7701    }
7702
7703    /**
7704     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7705     */
7706    public RatioRange getDefaultValueRatioRange() throws FHIRException { 
7707      if (this.defaultValue == null)
7708        this.defaultValue = new RatioRange();
7709      if (!(this.defaultValue instanceof RatioRange))
7710        throw new FHIRException("Type mismatch: the type RatioRange was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7711      return (RatioRange) this.defaultValue;
7712    }
7713
7714    public boolean hasDefaultValueRatioRange() { 
7715      return this != null && this.defaultValue instanceof RatioRange;
7716    }
7717
7718    /**
7719     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7720     */
7721    public Reference getDefaultValueReference() throws FHIRException { 
7722      if (this.defaultValue == null)
7723        this.defaultValue = new Reference();
7724      if (!(this.defaultValue instanceof Reference))
7725        throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7726      return (Reference) this.defaultValue;
7727    }
7728
7729    public boolean hasDefaultValueReference() { 
7730      return this != null && this.defaultValue instanceof Reference;
7731    }
7732
7733    /**
7734     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7735     */
7736    public SampledData getDefaultValueSampledData() throws FHIRException { 
7737      if (this.defaultValue == null)
7738        this.defaultValue = new SampledData();
7739      if (!(this.defaultValue instanceof SampledData))
7740        throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7741      return (SampledData) this.defaultValue;
7742    }
7743
7744    public boolean hasDefaultValueSampledData() { 
7745      return this != null && this.defaultValue instanceof SampledData;
7746    }
7747
7748    /**
7749     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7750     */
7751    public Signature getDefaultValueSignature() throws FHIRException { 
7752      if (this.defaultValue == null)
7753        this.defaultValue = new Signature();
7754      if (!(this.defaultValue instanceof Signature))
7755        throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7756      return (Signature) this.defaultValue;
7757    }
7758
7759    public boolean hasDefaultValueSignature() { 
7760      return this != null && this.defaultValue instanceof Signature;
7761    }
7762
7763    /**
7764     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7765     */
7766    public Timing getDefaultValueTiming() throws FHIRException { 
7767      if (this.defaultValue == null)
7768        this.defaultValue = new Timing();
7769      if (!(this.defaultValue instanceof Timing))
7770        throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7771      return (Timing) this.defaultValue;
7772    }
7773
7774    public boolean hasDefaultValueTiming() { 
7775      return this != null && this.defaultValue instanceof Timing;
7776    }
7777
7778    /**
7779     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7780     */
7781    public ContactDetail getDefaultValueContactDetail() throws FHIRException { 
7782      if (this.defaultValue == null)
7783        this.defaultValue = new ContactDetail();
7784      if (!(this.defaultValue instanceof ContactDetail))
7785        throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7786      return (ContactDetail) this.defaultValue;
7787    }
7788
7789    public boolean hasDefaultValueContactDetail() { 
7790      return this != null && this.defaultValue instanceof ContactDetail;
7791    }
7792
7793    /**
7794     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7795     */
7796    public DataRequirement getDefaultValueDataRequirement() throws FHIRException { 
7797      if (this.defaultValue == null)
7798        this.defaultValue = new DataRequirement();
7799      if (!(this.defaultValue instanceof DataRequirement))
7800        throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7801      return (DataRequirement) this.defaultValue;
7802    }
7803
7804    public boolean hasDefaultValueDataRequirement() { 
7805      return this != null && this.defaultValue instanceof DataRequirement;
7806    }
7807
7808    /**
7809     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7810     */
7811    public Expression getDefaultValueExpression() throws FHIRException { 
7812      if (this.defaultValue == null)
7813        this.defaultValue = new Expression();
7814      if (!(this.defaultValue instanceof Expression))
7815        throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7816      return (Expression) this.defaultValue;
7817    }
7818
7819    public boolean hasDefaultValueExpression() { 
7820      return this != null && this.defaultValue instanceof Expression;
7821    }
7822
7823    /**
7824     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7825     */
7826    public ParameterDefinition getDefaultValueParameterDefinition() throws FHIRException { 
7827      if (this.defaultValue == null)
7828        this.defaultValue = new ParameterDefinition();
7829      if (!(this.defaultValue instanceof ParameterDefinition))
7830        throw new FHIRException("Type mismatch: the type ParameterDefinition was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7831      return (ParameterDefinition) this.defaultValue;
7832    }
7833
7834    public boolean hasDefaultValueParameterDefinition() { 
7835      return this != null && this.defaultValue instanceof ParameterDefinition;
7836    }
7837
7838    /**
7839     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7840     */
7841    public RelatedArtifact getDefaultValueRelatedArtifact() throws FHIRException { 
7842      if (this.defaultValue == null)
7843        this.defaultValue = new RelatedArtifact();
7844      if (!(this.defaultValue instanceof RelatedArtifact))
7845        throw new FHIRException("Type mismatch: the type RelatedArtifact was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7846      return (RelatedArtifact) this.defaultValue;
7847    }
7848
7849    public boolean hasDefaultValueRelatedArtifact() { 
7850      return this != null && this.defaultValue instanceof RelatedArtifact;
7851    }
7852
7853    /**
7854     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7855     */
7856    public TriggerDefinition getDefaultValueTriggerDefinition() throws FHIRException { 
7857      if (this.defaultValue == null)
7858        this.defaultValue = new TriggerDefinition();
7859      if (!(this.defaultValue instanceof TriggerDefinition))
7860        throw new FHIRException("Type mismatch: the type TriggerDefinition was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7861      return (TriggerDefinition) this.defaultValue;
7862    }
7863
7864    public boolean hasDefaultValueTriggerDefinition() { 
7865      return this != null && this.defaultValue instanceof TriggerDefinition;
7866    }
7867
7868    /**
7869     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7870     */
7871    public UsageContext getDefaultValueUsageContext() throws FHIRException { 
7872      if (this.defaultValue == null)
7873        this.defaultValue = new UsageContext();
7874      if (!(this.defaultValue instanceof UsageContext))
7875        throw new FHIRException("Type mismatch: the type UsageContext was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7876      return (UsageContext) this.defaultValue;
7877    }
7878
7879    public boolean hasDefaultValueUsageContext() { 
7880      return this != null && this.defaultValue instanceof UsageContext;
7881    }
7882
7883    /**
7884     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7885     */
7886    public Availability getDefaultValueAvailability() throws FHIRException { 
7887      if (this.defaultValue == null)
7888        this.defaultValue = new Availability();
7889      if (!(this.defaultValue instanceof Availability))
7890        throw new FHIRException("Type mismatch: the type Availability was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7891      return (Availability) this.defaultValue;
7892    }
7893
7894    public boolean hasDefaultValueAvailability() { 
7895      return this != null && this.defaultValue instanceof Availability;
7896    }
7897
7898    /**
7899     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7900     */
7901    public ExtendedContactDetail getDefaultValueExtendedContactDetail() throws FHIRException { 
7902      if (this.defaultValue == null)
7903        this.defaultValue = new ExtendedContactDetail();
7904      if (!(this.defaultValue instanceof ExtendedContactDetail))
7905        throw new FHIRException("Type mismatch: the type ExtendedContactDetail was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7906      return (ExtendedContactDetail) this.defaultValue;
7907    }
7908
7909    public boolean hasDefaultValueExtendedContactDetail() { 
7910      return this != null && this.defaultValue instanceof ExtendedContactDetail;
7911    }
7912
7913    /**
7914     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7915     */
7916    public Dosage getDefaultValueDosage() throws FHIRException { 
7917      if (this.defaultValue == null)
7918        this.defaultValue = new Dosage();
7919      if (!(this.defaultValue instanceof Dosage))
7920        throw new FHIRException("Type mismatch: the type Dosage was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7921      return (Dosage) this.defaultValue;
7922    }
7923
7924    public boolean hasDefaultValueDosage() { 
7925      return this != null && this.defaultValue instanceof Dosage;
7926    }
7927
7928    /**
7929     * @return {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7930     */
7931    public Meta getDefaultValueMeta() throws FHIRException { 
7932      if (this.defaultValue == null)
7933        this.defaultValue = new Meta();
7934      if (!(this.defaultValue instanceof Meta))
7935        throw new FHIRException("Type mismatch: the type Meta was expected, but "+this.defaultValue.getClass().getName()+" was encountered");
7936      return (Meta) this.defaultValue;
7937    }
7938
7939    public boolean hasDefaultValueMeta() { 
7940      return this != null && this.defaultValue instanceof Meta;
7941    }
7942
7943    public boolean hasDefaultValue() { 
7944      return this.defaultValue != null && !this.defaultValue.isEmpty();
7945    }
7946
7947    /**
7948     * @param value {@link #defaultValue} (The value that should be used if there is no value stated in the instance (e.g. 'if not otherwise specified, the abstract is false').)
7949     */
7950    public ElementDefinition setDefaultValue(DataType value) { 
7951      if (value != null && !(value instanceof Base64BinaryType || value instanceof BooleanType || value instanceof CanonicalType || value instanceof CodeType || value instanceof DateType || value instanceof DateTimeType || value instanceof DecimalType || value instanceof IdType || value instanceof InstantType || value instanceof IntegerType || value instanceof Integer64Type || value instanceof MarkdownType || value instanceof OidType || value instanceof PositiveIntType || value instanceof StringType || value instanceof TimeType || value instanceof UnsignedIntType || value instanceof UriType || value instanceof UrlType || value instanceof UuidType || value instanceof Address || value instanceof Age || value instanceof Annotation || value instanceof Attachment || value instanceof CodeableConcept || value instanceof CodeableReference || value instanceof Coding || value instanceof ContactPoint || value instanceof Count || value instanceof Distance || value instanceof Duration || value instanceof HumanName || value instanceof Identifier || value instanceof Money || value instanceof Period || value instanceof Quantity || value instanceof Range || value instanceof Ratio || value instanceof RatioRange || value instanceof Reference || value instanceof SampledData || value instanceof Signature || value instanceof Timing || value instanceof ContactDetail || value instanceof DataRequirement || value instanceof Expression || value instanceof ParameterDefinition || value instanceof RelatedArtifact || value instanceof TriggerDefinition || value instanceof UsageContext || value instanceof Availability || value instanceof ExtendedContactDetail || value instanceof Dosage || value instanceof Meta))
7952        throw new FHIRException("Not the right type for ElementDefinition.defaultValue[x]: "+value.fhirType());
7953      this.defaultValue = value;
7954      return this;
7955    }
7956
7957    /**
7958     * @return {@link #meaningWhenMissing} (The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value
7959     */
7960    public MarkdownType getMeaningWhenMissingElement() { 
7961      if (this.meaningWhenMissing == null)
7962        if (Configuration.errorOnAutoCreate())
7963          throw new Error("Attempt to auto-create ElementDefinition.meaningWhenMissing");
7964        else if (Configuration.doAutoCreate())
7965          this.meaningWhenMissing = new MarkdownType(); // bb
7966      return this.meaningWhenMissing;
7967    }
7968
7969    public boolean hasMeaningWhenMissingElement() { 
7970      return this.meaningWhenMissing != null && !this.meaningWhenMissing.isEmpty();
7971    }
7972
7973    public boolean hasMeaningWhenMissing() { 
7974      return this.meaningWhenMissing != null && !this.meaningWhenMissing.isEmpty();
7975    }
7976
7977    /**
7978     * @param value {@link #meaningWhenMissing} (The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').). This is the underlying object with id, value and extensions. The accessor "getMeaningWhenMissing" gives direct access to the value
7979     */
7980    public ElementDefinition setMeaningWhenMissingElement(MarkdownType value) { 
7981      this.meaningWhenMissing = value;
7982      return this;
7983    }
7984
7985    /**
7986     * @return The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').
7987     */
7988    public String getMeaningWhenMissing() { 
7989      return this.meaningWhenMissing == null ? null : this.meaningWhenMissing.getValue();
7990    }
7991
7992    /**
7993     * @param value The Implicit meaning that is to be understood when this element is missing (e.g. 'when this element is missing, the period is ongoing').
7994     */
7995    public ElementDefinition setMeaningWhenMissing(String value) { 
7996      if (Utilities.noString(value))
7997        this.meaningWhenMissing = null;
7998      else {
7999        if (this.meaningWhenMissing == null)
8000          this.meaningWhenMissing = new MarkdownType();
8001        this.meaningWhenMissing.setValue(value);
8002      }
8003      return this;
8004    }
8005
8006    /**
8007     * @return {@link #orderMeaning} (If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value
8008     */
8009    public StringType getOrderMeaningElement() { 
8010      if (this.orderMeaning == null)
8011        if (Configuration.errorOnAutoCreate())
8012          throw new Error("Attempt to auto-create ElementDefinition.orderMeaning");
8013        else if (Configuration.doAutoCreate())
8014          this.orderMeaning = new StringType(); // bb
8015      return this.orderMeaning;
8016    }
8017
8018    public boolean hasOrderMeaningElement() { 
8019      return this.orderMeaning != null && !this.orderMeaning.isEmpty();
8020    }
8021
8022    public boolean hasOrderMeaning() { 
8023      return this.orderMeaning != null && !this.orderMeaning.isEmpty();
8024    }
8025
8026    /**
8027     * @param value {@link #orderMeaning} (If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning.). This is the underlying object with id, value and extensions. The accessor "getOrderMeaning" gives direct access to the value
8028     */
8029    public ElementDefinition setOrderMeaningElement(StringType value) { 
8030      this.orderMeaning = value;
8031      return this;
8032    }
8033
8034    /**
8035     * @return If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning.
8036     */
8037    public String getOrderMeaning() { 
8038      return this.orderMeaning == null ? null : this.orderMeaning.getValue();
8039    }
8040
8041    /**
8042     * @param value If present, indicates that the order of the repeating element has meaning and describes what that meaning is.  If absent, it means that the order of the element has no meaning.
8043     */
8044    public ElementDefinition setOrderMeaning(String value) { 
8045      if (Utilities.noString(value))
8046        this.orderMeaning = null;
8047      else {
8048        if (this.orderMeaning == null)
8049          this.orderMeaning = new StringType();
8050        this.orderMeaning.setValue(value);
8051      }
8052      return this;
8053    }
8054
8055    /**
8056     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8057     */
8058    public DataType getFixed() { 
8059      return this.fixed;
8060    }
8061
8062    /**
8063     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8064     */
8065    public Base64BinaryType getFixedBase64BinaryType() throws FHIRException { 
8066      if (this.fixed == null)
8067        this.fixed = new Base64BinaryType();
8068      if (!(this.fixed instanceof Base64BinaryType))
8069        throw new FHIRException("Type mismatch: the type Base64BinaryType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8070      return (Base64BinaryType) this.fixed;
8071    }
8072
8073    public boolean hasFixedBase64BinaryType() { 
8074      return this != null && this.fixed instanceof Base64BinaryType;
8075    }
8076
8077    /**
8078     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8079     */
8080    public BooleanType getFixedBooleanType() throws FHIRException { 
8081      if (this.fixed == null)
8082        this.fixed = new BooleanType();
8083      if (!(this.fixed instanceof BooleanType))
8084        throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8085      return (BooleanType) this.fixed;
8086    }
8087
8088    public boolean hasFixedBooleanType() { 
8089      return this != null && this.fixed instanceof BooleanType;
8090    }
8091
8092    /**
8093     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8094     */
8095    public CanonicalType getFixedCanonicalType() throws FHIRException { 
8096      if (this.fixed == null)
8097        this.fixed = new CanonicalType();
8098      if (!(this.fixed instanceof CanonicalType))
8099        throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8100      return (CanonicalType) this.fixed;
8101    }
8102
8103    public boolean hasFixedCanonicalType() { 
8104      return this != null && this.fixed instanceof CanonicalType;
8105    }
8106
8107    /**
8108     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8109     */
8110    public CodeType getFixedCodeType() throws FHIRException { 
8111      if (this.fixed == null)
8112        this.fixed = new CodeType();
8113      if (!(this.fixed instanceof CodeType))
8114        throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8115      return (CodeType) this.fixed;
8116    }
8117
8118    public boolean hasFixedCodeType() { 
8119      return this != null && this.fixed instanceof CodeType;
8120    }
8121
8122    /**
8123     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8124     */
8125    public DateType getFixedDateType() throws FHIRException { 
8126      if (this.fixed == null)
8127        this.fixed = new DateType();
8128      if (!(this.fixed instanceof DateType))
8129        throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8130      return (DateType) this.fixed;
8131    }
8132
8133    public boolean hasFixedDateType() { 
8134      return this != null && this.fixed instanceof DateType;
8135    }
8136
8137    /**
8138     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8139     */
8140    public DateTimeType getFixedDateTimeType() throws FHIRException { 
8141      if (this.fixed == null)
8142        this.fixed = new DateTimeType();
8143      if (!(this.fixed instanceof DateTimeType))
8144        throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8145      return (DateTimeType) this.fixed;
8146    }
8147
8148    public boolean hasFixedDateTimeType() { 
8149      return this != null && this.fixed instanceof DateTimeType;
8150    }
8151
8152    /**
8153     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8154     */
8155    public DecimalType getFixedDecimalType() throws FHIRException { 
8156      if (this.fixed == null)
8157        this.fixed = new DecimalType();
8158      if (!(this.fixed instanceof DecimalType))
8159        throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8160      return (DecimalType) this.fixed;
8161    }
8162
8163    public boolean hasFixedDecimalType() { 
8164      return this != null && this.fixed instanceof DecimalType;
8165    }
8166
8167    /**
8168     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8169     */
8170    public IdType getFixedIdType() throws FHIRException { 
8171      if (this.fixed == null)
8172        this.fixed = new IdType();
8173      if (!(this.fixed instanceof IdType))
8174        throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8175      return (IdType) this.fixed;
8176    }
8177
8178    public boolean hasFixedIdType() { 
8179      return this != null && this.fixed instanceof IdType;
8180    }
8181
8182    /**
8183     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8184     */
8185    public InstantType getFixedInstantType() throws FHIRException { 
8186      if (this.fixed == null)
8187        this.fixed = new InstantType();
8188      if (!(this.fixed instanceof InstantType))
8189        throw new FHIRException("Type mismatch: the type InstantType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8190      return (InstantType) this.fixed;
8191    }
8192
8193    public boolean hasFixedInstantType() { 
8194      return this != null && this.fixed instanceof InstantType;
8195    }
8196
8197    /**
8198     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8199     */
8200    public IntegerType getFixedIntegerType() throws FHIRException { 
8201      if (this.fixed == null)
8202        this.fixed = new IntegerType();
8203      if (!(this.fixed instanceof IntegerType))
8204        throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8205      return (IntegerType) this.fixed;
8206    }
8207
8208    public boolean hasFixedIntegerType() { 
8209      return this != null && this.fixed instanceof IntegerType;
8210    }
8211
8212    /**
8213     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8214     */
8215    public Integer64Type getFixedInteger64Type() throws FHIRException { 
8216      if (this.fixed == null)
8217        this.fixed = new Integer64Type();
8218      if (!(this.fixed instanceof Integer64Type))
8219        throw new FHIRException("Type mismatch: the type Integer64Type was expected, but "+this.fixed.getClass().getName()+" was encountered");
8220      return (Integer64Type) this.fixed;
8221    }
8222
8223    public boolean hasFixedInteger64Type() { 
8224      return this != null && this.fixed instanceof Integer64Type;
8225    }
8226
8227    /**
8228     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8229     */
8230    public MarkdownType getFixedMarkdownType() throws FHIRException { 
8231      if (this.fixed == null)
8232        this.fixed = new MarkdownType();
8233      if (!(this.fixed instanceof MarkdownType))
8234        throw new FHIRException("Type mismatch: the type MarkdownType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8235      return (MarkdownType) this.fixed;
8236    }
8237
8238    public boolean hasFixedMarkdownType() { 
8239      return this != null && this.fixed instanceof MarkdownType;
8240    }
8241
8242    /**
8243     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8244     */
8245    public OidType getFixedOidType() throws FHIRException { 
8246      if (this.fixed == null)
8247        this.fixed = new OidType();
8248      if (!(this.fixed instanceof OidType))
8249        throw new FHIRException("Type mismatch: the type OidType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8250      return (OidType) this.fixed;
8251    }
8252
8253    public boolean hasFixedOidType() { 
8254      return this != null && this.fixed instanceof OidType;
8255    }
8256
8257    /**
8258     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8259     */
8260    public PositiveIntType getFixedPositiveIntType() throws FHIRException { 
8261      if (this.fixed == null)
8262        this.fixed = new PositiveIntType();
8263      if (!(this.fixed instanceof PositiveIntType))
8264        throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8265      return (PositiveIntType) this.fixed;
8266    }
8267
8268    public boolean hasFixedPositiveIntType() { 
8269      return this != null && this.fixed instanceof PositiveIntType;
8270    }
8271
8272    /**
8273     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8274     */
8275    public StringType getFixedStringType() throws FHIRException { 
8276      if (this.fixed == null)
8277        this.fixed = new StringType();
8278      if (!(this.fixed instanceof StringType))
8279        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8280      return (StringType) this.fixed;
8281    }
8282
8283    public boolean hasFixedStringType() { 
8284      return this != null && this.fixed instanceof StringType;
8285    }
8286
8287    /**
8288     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8289     */
8290    public TimeType getFixedTimeType() throws FHIRException { 
8291      if (this.fixed == null)
8292        this.fixed = new TimeType();
8293      if (!(this.fixed instanceof TimeType))
8294        throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8295      return (TimeType) this.fixed;
8296    }
8297
8298    public boolean hasFixedTimeType() { 
8299      return this != null && this.fixed instanceof TimeType;
8300    }
8301
8302    /**
8303     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8304     */
8305    public UnsignedIntType getFixedUnsignedIntType() throws FHIRException { 
8306      if (this.fixed == null)
8307        this.fixed = new UnsignedIntType();
8308      if (!(this.fixed instanceof UnsignedIntType))
8309        throw new FHIRException("Type mismatch: the type UnsignedIntType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8310      return (UnsignedIntType) this.fixed;
8311    }
8312
8313    public boolean hasFixedUnsignedIntType() { 
8314      return this != null && this.fixed instanceof UnsignedIntType;
8315    }
8316
8317    /**
8318     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8319     */
8320    public UriType getFixedUriType() throws FHIRException { 
8321      if (this.fixed == null)
8322        this.fixed = new UriType();
8323      if (!(this.fixed instanceof UriType))
8324        throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8325      return (UriType) this.fixed;
8326    }
8327
8328    public boolean hasFixedUriType() { 
8329      return this != null && this.fixed instanceof UriType;
8330    }
8331
8332    /**
8333     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8334     */
8335    public UrlType getFixedUrlType() throws FHIRException { 
8336      if (this.fixed == null)
8337        this.fixed = new UrlType();
8338      if (!(this.fixed instanceof UrlType))
8339        throw new FHIRException("Type mismatch: the type UrlType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8340      return (UrlType) this.fixed;
8341    }
8342
8343    public boolean hasFixedUrlType() { 
8344      return this != null && this.fixed instanceof UrlType;
8345    }
8346
8347    /**
8348     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8349     */
8350    public UuidType getFixedUuidType() throws FHIRException { 
8351      if (this.fixed == null)
8352        this.fixed = new UuidType();
8353      if (!(this.fixed instanceof UuidType))
8354        throw new FHIRException("Type mismatch: the type UuidType was expected, but "+this.fixed.getClass().getName()+" was encountered");
8355      return (UuidType) this.fixed;
8356    }
8357
8358    public boolean hasFixedUuidType() { 
8359      return this != null && this.fixed instanceof UuidType;
8360    }
8361
8362    /**
8363     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8364     */
8365    public Address getFixedAddress() throws FHIRException { 
8366      if (this.fixed == null)
8367        this.fixed = new Address();
8368      if (!(this.fixed instanceof Address))
8369        throw new FHIRException("Type mismatch: the type Address was expected, but "+this.fixed.getClass().getName()+" was encountered");
8370      return (Address) this.fixed;
8371    }
8372
8373    public boolean hasFixedAddress() { 
8374      return this != null && this.fixed instanceof Address;
8375    }
8376
8377    /**
8378     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8379     */
8380    public Age getFixedAge() throws FHIRException { 
8381      if (this.fixed == null)
8382        this.fixed = new Age();
8383      if (!(this.fixed instanceof Age))
8384        throw new FHIRException("Type mismatch: the type Age was expected, but "+this.fixed.getClass().getName()+" was encountered");
8385      return (Age) this.fixed;
8386    }
8387
8388    public boolean hasFixedAge() { 
8389      return this != null && this.fixed instanceof Age;
8390    }
8391
8392    /**
8393     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8394     */
8395    public Annotation getFixedAnnotation() throws FHIRException { 
8396      if (this.fixed == null)
8397        this.fixed = new Annotation();
8398      if (!(this.fixed instanceof Annotation))
8399        throw new FHIRException("Type mismatch: the type Annotation was expected, but "+this.fixed.getClass().getName()+" was encountered");
8400      return (Annotation) this.fixed;
8401    }
8402
8403    public boolean hasFixedAnnotation() { 
8404      return this != null && this.fixed instanceof Annotation;
8405    }
8406
8407    /**
8408     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8409     */
8410    public Attachment getFixedAttachment() throws FHIRException { 
8411      if (this.fixed == null)
8412        this.fixed = new Attachment();
8413      if (!(this.fixed instanceof Attachment))
8414        throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.fixed.getClass().getName()+" was encountered");
8415      return (Attachment) this.fixed;
8416    }
8417
8418    public boolean hasFixedAttachment() { 
8419      return this != null && this.fixed instanceof Attachment;
8420    }
8421
8422    /**
8423     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8424     */
8425    public CodeableConcept getFixedCodeableConcept() throws FHIRException { 
8426      if (this.fixed == null)
8427        this.fixed = new CodeableConcept();
8428      if (!(this.fixed instanceof CodeableConcept))
8429        throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.fixed.getClass().getName()+" was encountered");
8430      return (CodeableConcept) this.fixed;
8431    }
8432
8433    public boolean hasFixedCodeableConcept() { 
8434      return this != null && this.fixed instanceof CodeableConcept;
8435    }
8436
8437    /**
8438     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8439     */
8440    public CodeableReference getFixedCodeableReference() throws FHIRException { 
8441      if (this.fixed == null)
8442        this.fixed = new CodeableReference();
8443      if (!(this.fixed instanceof CodeableReference))
8444        throw new FHIRException("Type mismatch: the type CodeableReference was expected, but "+this.fixed.getClass().getName()+" was encountered");
8445      return (CodeableReference) this.fixed;
8446    }
8447
8448    public boolean hasFixedCodeableReference() { 
8449      return this != null && this.fixed instanceof CodeableReference;
8450    }
8451
8452    /**
8453     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8454     */
8455    public Coding getFixedCoding() throws FHIRException { 
8456      if (this.fixed == null)
8457        this.fixed = new Coding();
8458      if (!(this.fixed instanceof Coding))
8459        throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.fixed.getClass().getName()+" was encountered");
8460      return (Coding) this.fixed;
8461    }
8462
8463    public boolean hasFixedCoding() { 
8464      return this != null && this.fixed instanceof Coding;
8465    }
8466
8467    /**
8468     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8469     */
8470    public ContactPoint getFixedContactPoint() throws FHIRException { 
8471      if (this.fixed == null)
8472        this.fixed = new ContactPoint();
8473      if (!(this.fixed instanceof ContactPoint))
8474        throw new FHIRException("Type mismatch: the type ContactPoint was expected, but "+this.fixed.getClass().getName()+" was encountered");
8475      return (ContactPoint) this.fixed;
8476    }
8477
8478    public boolean hasFixedContactPoint() { 
8479      return this != null && this.fixed instanceof ContactPoint;
8480    }
8481
8482    /**
8483     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8484     */
8485    public Count getFixedCount() throws FHIRException { 
8486      if (this.fixed == null)
8487        this.fixed = new Count();
8488      if (!(this.fixed instanceof Count))
8489        throw new FHIRException("Type mismatch: the type Count was expected, but "+this.fixed.getClass().getName()+" was encountered");
8490      return (Count) this.fixed;
8491    }
8492
8493    public boolean hasFixedCount() { 
8494      return this != null && this.fixed instanceof Count;
8495    }
8496
8497    /**
8498     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8499     */
8500    public Distance getFixedDistance() throws FHIRException { 
8501      if (this.fixed == null)
8502        this.fixed = new Distance();
8503      if (!(this.fixed instanceof Distance))
8504        throw new FHIRException("Type mismatch: the type Distance was expected, but "+this.fixed.getClass().getName()+" was encountered");
8505      return (Distance) this.fixed;
8506    }
8507
8508    public boolean hasFixedDistance() { 
8509      return this != null && this.fixed instanceof Distance;
8510    }
8511
8512    /**
8513     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8514     */
8515    public Duration getFixedDuration() throws FHIRException { 
8516      if (this.fixed == null)
8517        this.fixed = new Duration();
8518      if (!(this.fixed instanceof Duration))
8519        throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.fixed.getClass().getName()+" was encountered");
8520      return (Duration) this.fixed;
8521    }
8522
8523    public boolean hasFixedDuration() { 
8524      return this != null && this.fixed instanceof Duration;
8525    }
8526
8527    /**
8528     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8529     */
8530    public HumanName getFixedHumanName() throws FHIRException { 
8531      if (this.fixed == null)
8532        this.fixed = new HumanName();
8533      if (!(this.fixed instanceof HumanName))
8534        throw new FHIRException("Type mismatch: the type HumanName was expected, but "+this.fixed.getClass().getName()+" was encountered");
8535      return (HumanName) this.fixed;
8536    }
8537
8538    public boolean hasFixedHumanName() { 
8539      return this != null && this.fixed instanceof HumanName;
8540    }
8541
8542    /**
8543     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8544     */
8545    public Identifier getFixedIdentifier() throws FHIRException { 
8546      if (this.fixed == null)
8547        this.fixed = new Identifier();
8548      if (!(this.fixed instanceof Identifier))
8549        throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.fixed.getClass().getName()+" was encountered");
8550      return (Identifier) this.fixed;
8551    }
8552
8553    public boolean hasFixedIdentifier() { 
8554      return this != null && this.fixed instanceof Identifier;
8555    }
8556
8557    /**
8558     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8559     */
8560    public Money getFixedMoney() throws FHIRException { 
8561      if (this.fixed == null)
8562        this.fixed = new Money();
8563      if (!(this.fixed instanceof Money))
8564        throw new FHIRException("Type mismatch: the type Money was expected, but "+this.fixed.getClass().getName()+" was encountered");
8565      return (Money) this.fixed;
8566    }
8567
8568    public boolean hasFixedMoney() { 
8569      return this != null && this.fixed instanceof Money;
8570    }
8571
8572    /**
8573     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8574     */
8575    public Period getFixedPeriod() throws FHIRException { 
8576      if (this.fixed == null)
8577        this.fixed = new Period();
8578      if (!(this.fixed instanceof Period))
8579        throw new FHIRException("Type mismatch: the type Period was expected, but "+this.fixed.getClass().getName()+" was encountered");
8580      return (Period) this.fixed;
8581    }
8582
8583    public boolean hasFixedPeriod() { 
8584      return this != null && this.fixed instanceof Period;
8585    }
8586
8587    /**
8588     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8589     */
8590    public Quantity getFixedQuantity() throws FHIRException { 
8591      if (this.fixed == null)
8592        this.fixed = new Quantity();
8593      if (!(this.fixed instanceof Quantity))
8594        throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.fixed.getClass().getName()+" was encountered");
8595      return (Quantity) this.fixed;
8596    }
8597
8598    public boolean hasFixedQuantity() { 
8599      return this != null && this.fixed instanceof Quantity;
8600    }
8601
8602    /**
8603     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8604     */
8605    public Range getFixedRange() throws FHIRException { 
8606      if (this.fixed == null)
8607        this.fixed = new Range();
8608      if (!(this.fixed instanceof Range))
8609        throw new FHIRException("Type mismatch: the type Range was expected, but "+this.fixed.getClass().getName()+" was encountered");
8610      return (Range) this.fixed;
8611    }
8612
8613    public boolean hasFixedRange() { 
8614      return this != null && this.fixed instanceof Range;
8615    }
8616
8617    /**
8618     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8619     */
8620    public Ratio getFixedRatio() throws FHIRException { 
8621      if (this.fixed == null)
8622        this.fixed = new Ratio();
8623      if (!(this.fixed instanceof Ratio))
8624        throw new FHIRException("Type mismatch: the type Ratio was expected, but "+this.fixed.getClass().getName()+" was encountered");
8625      return (Ratio) this.fixed;
8626    }
8627
8628    public boolean hasFixedRatio() { 
8629      return this != null && this.fixed instanceof Ratio;
8630    }
8631
8632    /**
8633     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8634     */
8635    public RatioRange getFixedRatioRange() throws FHIRException { 
8636      if (this.fixed == null)
8637        this.fixed = new RatioRange();
8638      if (!(this.fixed instanceof RatioRange))
8639        throw new FHIRException("Type mismatch: the type RatioRange was expected, but "+this.fixed.getClass().getName()+" was encountered");
8640      return (RatioRange) this.fixed;
8641    }
8642
8643    public boolean hasFixedRatioRange() { 
8644      return this != null && this.fixed instanceof RatioRange;
8645    }
8646
8647    /**
8648     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8649     */
8650    public Reference getFixedReference() throws FHIRException { 
8651      if (this.fixed == null)
8652        this.fixed = new Reference();
8653      if (!(this.fixed instanceof Reference))
8654        throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.fixed.getClass().getName()+" was encountered");
8655      return (Reference) this.fixed;
8656    }
8657
8658    public boolean hasFixedReference() { 
8659      return this != null && this.fixed instanceof Reference;
8660    }
8661
8662    /**
8663     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8664     */
8665    public SampledData getFixedSampledData() throws FHIRException { 
8666      if (this.fixed == null)
8667        this.fixed = new SampledData();
8668      if (!(this.fixed instanceof SampledData))
8669        throw new FHIRException("Type mismatch: the type SampledData was expected, but "+this.fixed.getClass().getName()+" was encountered");
8670      return (SampledData) this.fixed;
8671    }
8672
8673    public boolean hasFixedSampledData() { 
8674      return this != null && this.fixed instanceof SampledData;
8675    }
8676
8677    /**
8678     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8679     */
8680    public Signature getFixedSignature() throws FHIRException { 
8681      if (this.fixed == null)
8682        this.fixed = new Signature();
8683      if (!(this.fixed instanceof Signature))
8684        throw new FHIRException("Type mismatch: the type Signature was expected, but "+this.fixed.getClass().getName()+" was encountered");
8685      return (Signature) this.fixed;
8686    }
8687
8688    public boolean hasFixedSignature() { 
8689      return this != null && this.fixed instanceof Signature;
8690    }
8691
8692    /**
8693     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8694     */
8695    public Timing getFixedTiming() throws FHIRException { 
8696      if (this.fixed == null)
8697        this.fixed = new Timing();
8698      if (!(this.fixed instanceof Timing))
8699        throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.fixed.getClass().getName()+" was encountered");
8700      return (Timing) this.fixed;
8701    }
8702
8703    public boolean hasFixedTiming() { 
8704      return this != null && this.fixed instanceof Timing;
8705    }
8706
8707    /**
8708     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8709     */
8710    public ContactDetail getFixedContactDetail() throws FHIRException { 
8711      if (this.fixed == null)
8712        this.fixed = new ContactDetail();
8713      if (!(this.fixed instanceof ContactDetail))
8714        throw new FHIRException("Type mismatch: the type ContactDetail was expected, but "+this.fixed.getClass().getName()+" was encountered");
8715      return (ContactDetail) this.fixed;
8716    }
8717
8718    public boolean hasFixedContactDetail() { 
8719      return this != null && this.fixed instanceof ContactDetail;
8720    }
8721
8722    /**
8723     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8724     */
8725    public DataRequirement getFixedDataRequirement() throws FHIRException { 
8726      if (this.fixed == null)
8727        this.fixed = new DataRequirement();
8728      if (!(this.fixed instanceof DataRequirement))
8729        throw new FHIRException("Type mismatch: the type DataRequirement was expected, but "+this.fixed.getClass().getName()+" was encountered");
8730      return (DataRequirement) this.fixed;
8731    }
8732
8733    public boolean hasFixedDataRequirement() { 
8734      return this != null && this.fixed instanceof DataRequirement;
8735    }
8736
8737    /**
8738     * @return {@link #fixed} (Specifies a value that SHALL be exactly the value  for this element in the instance, if present. For purposes of comparison, non-significant whitespace is ignored, and all values must be an exact match (case and accent sensitive). Missing elements/attributes must also be missing.)
8739     */
8740    public Expression getFixedExpression() throws FHIRException { 
8741      if (this.fixed == null)
8742        this.fixed = new Expression();
8743      if (!(this.fixed instanceof Expression))
8744        throw new FHIRException("Type mismatch: the type Expression was expected, but "+this.fixed.getClass().getName()+" was encountered");