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