001package org.hl7.fhir.dstu3.model;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
035import java.util.ArrayList;
036import java.util.Date;
037import java.util.List;
038
039import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatus;
040import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatusEnumFactory;
041import org.hl7.fhir.exceptions.FHIRException;
042import org.hl7.fhir.exceptions.FHIRFormatError;
043import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
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.ChildOrder;
049import ca.uhn.fhir.model.api.annotation.Description;
050import ca.uhn.fhir.model.api.annotation.ResourceDef;
051import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
052/**
053 * A value set specifies a set of codes drawn from one or more code systems.
054 */
055@ResourceDef(name="ValueSet", profile="http://hl7.org/fhir/Profile/ValueSet")
056@ChildOrder(names={"url", "identifier", "version", "name", "title", "status", "experimental", "date", "publisher", "contact", "description", "useContext", "jurisdiction", "immutable", "purpose", "copyright", "extensible", "compose", "expansion"})
057public class ValueSet extends MetadataResource {
058
059    public enum FilterOperator {
060        /**
061         * The specified property of the code equals the provided value.
062         */
063        EQUAL, 
064        /**
065         * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (i.e. include child codes)
066         */
067        ISA, 
068        /**
069         * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include child codes)
070         */
071        DESCENDENTOF, 
072        /**
073         * The specified property of the code does not have an is-a relationship with the provided value.
074         */
075        ISNOTA, 
076        /**
077         * The specified property of the code  matches the regex specified in the provided value.
078         */
079        REGEX, 
080        /**
081         * The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list).
082         */
083        IN, 
084        /**
085         * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list).
086         */
087        NOTIN, 
088        /**
089         * Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (e.g. include parent codes)
090         */
091        GENERALIZES, 
092        /**
093         * The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values)
094         */
095        EXISTS, 
096        /**
097         * added to help the parsers with the generic types
098         */
099        NULL;
100        public static FilterOperator fromCode(String codeString) throws FHIRException {
101            if (codeString == null || "".equals(codeString))
102                return null;
103        if ("=".equals(codeString))
104          return EQUAL;
105        if ("is-a".equals(codeString))
106          return ISA;
107        if ("descendent-of".equals(codeString))
108          return DESCENDENTOF;
109        if ("is-not-a".equals(codeString))
110          return ISNOTA;
111        if ("regex".equals(codeString))
112          return REGEX;
113        if ("in".equals(codeString))
114          return IN;
115        if ("not-in".equals(codeString))
116          return NOTIN;
117        if ("generalizes".equals(codeString))
118          return GENERALIZES;
119        if ("exists".equals(codeString))
120          return EXISTS;
121        if (Configuration.isAcceptInvalidEnums())
122          return null;
123        else
124          throw new FHIRException("Unknown FilterOperator code '"+codeString+"'");
125        }
126        public String toCode() {
127          switch (this) {
128            case EQUAL: return "=";
129            case ISA: return "is-a";
130            case DESCENDENTOF: return "descendent-of";
131            case ISNOTA: return "is-not-a";
132            case REGEX: return "regex";
133            case IN: return "in";
134            case NOTIN: return "not-in";
135            case GENERALIZES: return "generalizes";
136            case EXISTS: return "exists";
137            case NULL: return null;
138            default: return "?";
139          }
140        }
141        public String getSystem() {
142          switch (this) {
143            case EQUAL: return "http://hl7.org/fhir/filter-operator";
144            case ISA: return "http://hl7.org/fhir/filter-operator";
145            case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator";
146            case ISNOTA: return "http://hl7.org/fhir/filter-operator";
147            case REGEX: return "http://hl7.org/fhir/filter-operator";
148            case IN: return "http://hl7.org/fhir/filter-operator";
149            case NOTIN: return "http://hl7.org/fhir/filter-operator";
150            case GENERALIZES: return "http://hl7.org/fhir/filter-operator";
151            case EXISTS: return "http://hl7.org/fhir/filter-operator";
152            case NULL: return null;
153            default: return "?";
154          }
155        }
156        public String getDefinition() {
157          switch (this) {
158            case EQUAL: return "The specified property of the code equals the provided value.";
159            case ISA: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (i.e. include child codes)";
160            case DESCENDENTOF: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include child codes)";
161            case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value.";
162            case REGEX: return "The specified property of the code  matches the regex specified in the provided value.";
163            case IN: return "The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list).";
164            case NOTIN: return "The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list).";
165            case GENERALIZES: return "Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (e.g. include parent codes)";
166            case EXISTS: return "The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values)";
167            case NULL: return null;
168            default: return "?";
169          }
170        }
171        public String getDisplay() {
172          switch (this) {
173            case EQUAL: return "Equals";
174            case ISA: return "Is A (by subsumption)";
175            case DESCENDENTOF: return "Descendent Of (by subsumption)";
176            case ISNOTA: return "Not (Is A) (by subsumption)";
177            case REGEX: return "Regular Expression";
178            case IN: return "In Set";
179            case NOTIN: return "Not in Set";
180            case GENERALIZES: return "Generalizes (by Subsumption)";
181            case EXISTS: return "Exists";
182            case NULL: return null;
183            default: return "?";
184          }
185        }
186    }
187
188  public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> {
189    public FilterOperator fromCode(String codeString) throws IllegalArgumentException {
190      if (codeString == null || "".equals(codeString))
191            if (codeString == null || "".equals(codeString))
192                return null;
193        if ("=".equals(codeString))
194          return FilterOperator.EQUAL;
195        if ("is-a".equals(codeString))
196          return FilterOperator.ISA;
197        if ("descendent-of".equals(codeString))
198          return FilterOperator.DESCENDENTOF;
199        if ("is-not-a".equals(codeString))
200          return FilterOperator.ISNOTA;
201        if ("regex".equals(codeString))
202          return FilterOperator.REGEX;
203        if ("in".equals(codeString))
204          return FilterOperator.IN;
205        if ("not-in".equals(codeString))
206          return FilterOperator.NOTIN;
207        if ("generalizes".equals(codeString))
208          return FilterOperator.GENERALIZES;
209        if ("exists".equals(codeString))
210          return FilterOperator.EXISTS;
211        throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'");
212        }
213        public Enumeration<FilterOperator> fromType(Base code) throws FHIRException {
214          if (code == null)
215            return null;
216          if (code.isEmpty())
217            return new Enumeration<FilterOperator>(this);
218          String codeString = ((PrimitiveType) code).asStringValue();
219          if (codeString == null || "".equals(codeString))
220            return null;
221        if ("=".equals(codeString))
222          return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL);
223        if ("is-a".equals(codeString))
224          return new Enumeration<FilterOperator>(this, FilterOperator.ISA);
225        if ("descendent-of".equals(codeString))
226          return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF);
227        if ("is-not-a".equals(codeString))
228          return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA);
229        if ("regex".equals(codeString))
230          return new Enumeration<FilterOperator>(this, FilterOperator.REGEX);
231        if ("in".equals(codeString))
232          return new Enumeration<FilterOperator>(this, FilterOperator.IN);
233        if ("not-in".equals(codeString))
234          return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN);
235        if ("generalizes".equals(codeString))
236          return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES);
237        if ("exists".equals(codeString))
238          return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS);
239        throw new FHIRException("Unknown FilterOperator code '"+codeString+"'");
240        }
241    public String toCode(FilterOperator code) {
242      if (code == FilterOperator.EQUAL)
243        return "=";
244      if (code == FilterOperator.ISA)
245        return "is-a";
246      if (code == FilterOperator.DESCENDENTOF)
247        return "descendent-of";
248      if (code == FilterOperator.ISNOTA)
249        return "is-not-a";
250      if (code == FilterOperator.REGEX)
251        return "regex";
252      if (code == FilterOperator.IN)
253        return "in";
254      if (code == FilterOperator.NOTIN)
255        return "not-in";
256      if (code == FilterOperator.GENERALIZES)
257        return "generalizes";
258      if (code == FilterOperator.EXISTS)
259        return "exists";
260      return "?";
261      }
262    public String toSystem(FilterOperator code) {
263      return code.getSystem();
264      }
265    }
266
267    @Block()
268    public static class ValueSetComposeComponent extends BackboneElement implements IBaseBackboneElement {
269        /**
270         * If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.
271         */
272        @Child(name = "lockedDate", type = {DateType.class}, order=1, min=0, max=1, modifier=false, summary=true)
273        @Description(shortDefinition="Fixed date for version-less references (transitive)", formalDefinition="If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined." )
274        protected DateType lockedDate;
275
276        /**
277         * Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).
278         */
279        @Child(name = "inactive", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=true)
280        @Description(shortDefinition="Whether inactive codes are in the value set", formalDefinition="Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included)." )
281        protected BooleanType inactive;
282
283        /**
284         * Include one or more codes from a code system or other value set(s).
285         */
286        @Child(name = "include", type = {}, order=3, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
287        @Description(shortDefinition="Include one or more codes from a code system or other value set(s)", formalDefinition="Include one or more codes from a code system or other value set(s)." )
288        protected List<ConceptSetComponent> include;
289
290        /**
291         * Exclude one or more codes from the value set based on code system filters and/or other value sets.
292         */
293        @Child(name = "exclude", type = {ConceptSetComponent.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
294        @Description(shortDefinition="Explicitly exclude codes from a code system or other value sets", formalDefinition="Exclude one or more codes from the value set based on code system filters and/or other value sets." )
295        protected List<ConceptSetComponent> exclude;
296
297        private static final long serialVersionUID = -765941757L;
298
299    /**
300     * Constructor
301     */
302      public ValueSetComposeComponent() {
303        super();
304      }
305
306        /**
307         * @return {@link #lockedDate} (If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.). This is the underlying object with id, value and extensions. The accessor "getLockedDate" gives direct access to the value
308         */
309        public DateType getLockedDateElement() { 
310          if (this.lockedDate == null)
311            if (Configuration.errorOnAutoCreate())
312              throw new Error("Attempt to auto-create ValueSetComposeComponent.lockedDate");
313            else if (Configuration.doAutoCreate())
314              this.lockedDate = new DateType(); // bb
315          return this.lockedDate;
316        }
317
318        public boolean hasLockedDateElement() { 
319          return this.lockedDate != null && !this.lockedDate.isEmpty();
320        }
321
322        public boolean hasLockedDate() { 
323          return this.lockedDate != null && !this.lockedDate.isEmpty();
324        }
325
326        /**
327         * @param value {@link #lockedDate} (If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.). This is the underlying object with id, value and extensions. The accessor "getLockedDate" gives direct access to the value
328         */
329        public ValueSetComposeComponent setLockedDateElement(DateType value) { 
330          this.lockedDate = value;
331          return this;
332        }
333
334        /**
335         * @return If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.
336         */
337        public Date getLockedDate() { 
338          return this.lockedDate == null ? null : this.lockedDate.getValue();
339        }
340
341        /**
342         * @param value If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.
343         */
344        public ValueSetComposeComponent setLockedDate(Date value) { 
345          if (value == null)
346            this.lockedDate = null;
347          else {
348            if (this.lockedDate == null)
349              this.lockedDate = new DateType();
350            this.lockedDate.setValue(value);
351          }
352          return this;
353        }
354
355        /**
356         * @return {@link #inactive} (Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value
357         */
358        public BooleanType getInactiveElement() { 
359          if (this.inactive == null)
360            if (Configuration.errorOnAutoCreate())
361              throw new Error("Attempt to auto-create ValueSetComposeComponent.inactive");
362            else if (Configuration.doAutoCreate())
363              this.inactive = new BooleanType(); // bb
364          return this.inactive;
365        }
366
367        public boolean hasInactiveElement() { 
368          return this.inactive != null && !this.inactive.isEmpty();
369        }
370
371        public boolean hasInactive() { 
372          return this.inactive != null && !this.inactive.isEmpty();
373        }
374
375        /**
376         * @param value {@link #inactive} (Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value
377         */
378        public ValueSetComposeComponent setInactiveElement(BooleanType value) { 
379          this.inactive = value;
380          return this;
381        }
382
383        /**
384         * @return Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).
385         */
386        public boolean getInactive() { 
387          return this.inactive == null || this.inactive.isEmpty() ? false : this.inactive.getValue();
388        }
389
390        /**
391         * @param value Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).
392         */
393        public ValueSetComposeComponent setInactive(boolean value) { 
394            if (this.inactive == null)
395              this.inactive = new BooleanType();
396            this.inactive.setValue(value);
397          return this;
398        }
399
400        /**
401         * @return {@link #include} (Include one or more codes from a code system or other value set(s).)
402         */
403        public List<ConceptSetComponent> getInclude() { 
404          if (this.include == null)
405            this.include = new ArrayList<ConceptSetComponent>();
406          return this.include;
407        }
408
409        /**
410         * @return Returns a reference to <code>this</code> for easy method chaining
411         */
412        public ValueSetComposeComponent setInclude(List<ConceptSetComponent> theInclude) { 
413          this.include = theInclude;
414          return this;
415        }
416
417        public boolean hasInclude() { 
418          if (this.include == null)
419            return false;
420          for (ConceptSetComponent item : this.include)
421            if (!item.isEmpty())
422              return true;
423          return false;
424        }
425
426        public ConceptSetComponent addInclude() { //3
427          ConceptSetComponent t = new ConceptSetComponent();
428          if (this.include == null)
429            this.include = new ArrayList<ConceptSetComponent>();
430          this.include.add(t);
431          return t;
432        }
433
434        public ValueSetComposeComponent addInclude(ConceptSetComponent t) { //3
435          if (t == null)
436            return this;
437          if (this.include == null)
438            this.include = new ArrayList<ConceptSetComponent>();
439          this.include.add(t);
440          return this;
441        }
442
443        /**
444         * @return The first repetition of repeating field {@link #include}, creating it if it does not already exist
445         */
446        public ConceptSetComponent getIncludeFirstRep() { 
447          if (getInclude().isEmpty()) {
448            addInclude();
449          }
450          return getInclude().get(0);
451        }
452
453        /**
454         * @return {@link #exclude} (Exclude one or more codes from the value set based on code system filters and/or other value sets.)
455         */
456        public List<ConceptSetComponent> getExclude() { 
457          if (this.exclude == null)
458            this.exclude = new ArrayList<ConceptSetComponent>();
459          return this.exclude;
460        }
461
462        /**
463         * @return Returns a reference to <code>this</code> for easy method chaining
464         */
465        public ValueSetComposeComponent setExclude(List<ConceptSetComponent> theExclude) { 
466          this.exclude = theExclude;
467          return this;
468        }
469
470        public boolean hasExclude() { 
471          if (this.exclude == null)
472            return false;
473          for (ConceptSetComponent item : this.exclude)
474            if (!item.isEmpty())
475              return true;
476          return false;
477        }
478
479        public ConceptSetComponent addExclude() { //3
480          ConceptSetComponent t = new ConceptSetComponent();
481          if (this.exclude == null)
482            this.exclude = new ArrayList<ConceptSetComponent>();
483          this.exclude.add(t);
484          return t;
485        }
486
487        public ValueSetComposeComponent addExclude(ConceptSetComponent t) { //3
488          if (t == null)
489            return this;
490          if (this.exclude == null)
491            this.exclude = new ArrayList<ConceptSetComponent>();
492          this.exclude.add(t);
493          return this;
494        }
495
496        /**
497         * @return The first repetition of repeating field {@link #exclude}, creating it if it does not already exist
498         */
499        public ConceptSetComponent getExcludeFirstRep() { 
500          if (getExclude().isEmpty()) {
501            addExclude();
502          }
503          return getExclude().get(0);
504        }
505
506        protected void listChildren(List<Property> children) {
507          super.listChildren(children);
508          children.add(new Property("lockedDate", "date", "If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.", 0, 1, lockedDate));
509          children.add(new Property("inactive", "boolean", "Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).", 0, 1, inactive));
510          children.add(new Property("include", "", "Include one or more codes from a code system or other value set(s).", 0, java.lang.Integer.MAX_VALUE, include));
511          children.add(new Property("exclude", "@ValueSet.compose.include", "Exclude one or more codes from the value set based on code system filters and/or other value sets.", 0, java.lang.Integer.MAX_VALUE, exclude));
512        }
513
514        @Override
515        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
516          switch (_hash) {
517          case 1391591896: /*lockedDate*/  return new Property("lockedDate", "date", "If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.", 0, 1, lockedDate);
518          case 24665195: /*inactive*/  return new Property("inactive", "boolean", "Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).", 0, 1, inactive);
519          case 1942574248: /*include*/  return new Property("include", "", "Include one or more codes from a code system or other value set(s).", 0, java.lang.Integer.MAX_VALUE, include);
520          case -1321148966: /*exclude*/  return new Property("exclude", "@ValueSet.compose.include", "Exclude one or more codes from the value set based on code system filters and/or other value sets.", 0, java.lang.Integer.MAX_VALUE, exclude);
521          default: return super.getNamedProperty(_hash, _name, _checkValid);
522          }
523
524        }
525
526      @Override
527      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
528        switch (hash) {
529        case 1391591896: /*lockedDate*/ return this.lockedDate == null ? new Base[0] : new Base[] {this.lockedDate}; // DateType
530        case 24665195: /*inactive*/ return this.inactive == null ? new Base[0] : new Base[] {this.inactive}; // BooleanType
531        case 1942574248: /*include*/ return this.include == null ? new Base[0] : this.include.toArray(new Base[this.include.size()]); // ConceptSetComponent
532        case -1321148966: /*exclude*/ return this.exclude == null ? new Base[0] : this.exclude.toArray(new Base[this.exclude.size()]); // ConceptSetComponent
533        default: return super.getProperty(hash, name, checkValid);
534        }
535
536      }
537
538      @Override
539      public Base setProperty(int hash, String name, Base value) throws FHIRException {
540        switch (hash) {
541        case 1391591896: // lockedDate
542          this.lockedDate = castToDate(value); // DateType
543          return value;
544        case 24665195: // inactive
545          this.inactive = castToBoolean(value); // BooleanType
546          return value;
547        case 1942574248: // include
548          this.getInclude().add((ConceptSetComponent) value); // ConceptSetComponent
549          return value;
550        case -1321148966: // exclude
551          this.getExclude().add((ConceptSetComponent) value); // ConceptSetComponent
552          return value;
553        default: return super.setProperty(hash, name, value);
554        }
555
556      }
557
558      @Override
559      public Base setProperty(String name, Base value) throws FHIRException {
560        if (name.equals("lockedDate")) {
561          this.lockedDate = castToDate(value); // DateType
562        } else if (name.equals("inactive")) {
563          this.inactive = castToBoolean(value); // BooleanType
564        } else if (name.equals("include")) {
565          this.getInclude().add((ConceptSetComponent) value);
566        } else if (name.equals("exclude")) {
567          this.getExclude().add((ConceptSetComponent) value);
568        } else
569          return super.setProperty(name, value);
570        return value;
571      }
572
573      @Override
574      public Base makeProperty(int hash, String name) throws FHIRException {
575        switch (hash) {
576        case 1391591896:  return getLockedDateElement();
577        case 24665195:  return getInactiveElement();
578        case 1942574248:  return addInclude(); 
579        case -1321148966:  return addExclude(); 
580        default: return super.makeProperty(hash, name);
581        }
582
583      }
584
585      @Override
586      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
587        switch (hash) {
588        case 1391591896: /*lockedDate*/ return new String[] {"date"};
589        case 24665195: /*inactive*/ return new String[] {"boolean"};
590        case 1942574248: /*include*/ return new String[] {};
591        case -1321148966: /*exclude*/ return new String[] {"@ValueSet.compose.include"};
592        default: return super.getTypesForProperty(hash, name);
593        }
594
595      }
596
597      @Override
598      public Base addChild(String name) throws FHIRException {
599        if (name.equals("lockedDate")) {
600          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.lockedDate");
601        }
602        else if (name.equals("inactive")) {
603          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.inactive");
604        }
605        else if (name.equals("include")) {
606          return addInclude();
607        }
608        else if (name.equals("exclude")) {
609          return addExclude();
610        }
611        else
612          return super.addChild(name);
613      }
614
615      public ValueSetComposeComponent copy() {
616        ValueSetComposeComponent dst = new ValueSetComposeComponent();
617        copyValues(dst);
618        dst.lockedDate = lockedDate == null ? null : lockedDate.copy();
619        dst.inactive = inactive == null ? null : inactive.copy();
620        if (include != null) {
621          dst.include = new ArrayList<ConceptSetComponent>();
622          for (ConceptSetComponent i : include)
623            dst.include.add(i.copy());
624        };
625        if (exclude != null) {
626          dst.exclude = new ArrayList<ConceptSetComponent>();
627          for (ConceptSetComponent i : exclude)
628            dst.exclude.add(i.copy());
629        };
630        return dst;
631      }
632
633      @Override
634      public boolean equalsDeep(Base other_) {
635        if (!super.equalsDeep(other_))
636          return false;
637        if (!(other_ instanceof ValueSetComposeComponent))
638          return false;
639        ValueSetComposeComponent o = (ValueSetComposeComponent) other_;
640        return compareDeep(lockedDate, o.lockedDate, true) && compareDeep(inactive, o.inactive, true) && compareDeep(include, o.include, true)
641           && compareDeep(exclude, o.exclude, true);
642      }
643
644      @Override
645      public boolean equalsShallow(Base other_) {
646        if (!super.equalsShallow(other_))
647          return false;
648        if (!(other_ instanceof ValueSetComposeComponent))
649          return false;
650        ValueSetComposeComponent o = (ValueSetComposeComponent) other_;
651        return compareValues(lockedDate, o.lockedDate, true) && compareValues(inactive, o.inactive, true);
652      }
653
654      public boolean isEmpty() {
655        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(lockedDate, inactive, include
656          , exclude);
657      }
658
659  public String fhirType() {
660    return "ValueSet.compose";
661
662  }
663
664  }
665
666    @Block()
667    public static class ConceptSetComponent extends BackboneElement implements IBaseBackboneElement {
668        /**
669         * An absolute URI which is the code system from which the selected codes come from.
670         */
671        @Child(name = "system", type = {UriType.class}, order=1, min=0, max=1, modifier=false, summary=true)
672        @Description(shortDefinition="The system the codes come from", formalDefinition="An absolute URI which is the code system from which the selected codes come from." )
673        protected UriType system;
674
675        /**
676         * The version of the code system that the codes are selected from.
677         */
678        @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
679        @Description(shortDefinition="Specific version of the code system referred to", formalDefinition="The version of the code system that the codes are selected from." )
680        protected StringType version;
681
682        /**
683         * Specifies a concept to be included or excluded.
684         */
685        @Child(name = "concept", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
686        @Description(shortDefinition="A concept defined in the system", formalDefinition="Specifies a concept to be included or excluded." )
687        protected List<ConceptReferenceComponent> concept;
688
689        /**
690         * Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.
691         */
692        @Child(name = "filter", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=true, summary=true)
693        @Description(shortDefinition="Select codes/concepts by their properties (including relationships)", formalDefinition="Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true." )
694        protected List<ConceptSetFilterComponent> filter;
695
696        /**
697         * Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.
698         */
699        @Child(name = "valueSet", type = {UriType.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
700        @Description(shortDefinition="Select only contents included in this value set", formalDefinition="Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url." )
701        protected List<UriType> valueSet;
702
703        private static final long serialVersionUID = -1322183438L;
704
705    /**
706     * Constructor
707     */
708      public ConceptSetComponent() {
709        super();
710      }
711
712        /**
713         * @return {@link #system} (An absolute URI which is the code system from which the selected codes come from.). This is the underlying object with id, value and extensions. The accessor "getSystem" gives direct access to the value
714         */
715        public UriType getSystemElement() { 
716          if (this.system == null)
717            if (Configuration.errorOnAutoCreate())
718              throw new Error("Attempt to auto-create ConceptSetComponent.system");
719            else if (Configuration.doAutoCreate())
720              this.system = new UriType(); // bb
721          return this.system;
722        }
723
724        public boolean hasSystemElement() { 
725          return this.system != null && !this.system.isEmpty();
726        }
727
728        public boolean hasSystem() { 
729          return this.system != null && !this.system.isEmpty();
730        }
731
732        /**
733         * @param value {@link #system} (An absolute URI which is the code system from which the selected codes come from.). This is the underlying object with id, value and extensions. The accessor "getSystem" gives direct access to the value
734         */
735        public ConceptSetComponent setSystemElement(UriType value) { 
736          this.system = value;
737          return this;
738        }
739
740        /**
741         * @return An absolute URI which is the code system from which the selected codes come from.
742         */
743        public String getSystem() { 
744          return this.system == null ? null : this.system.getValue();
745        }
746
747        /**
748         * @param value An absolute URI which is the code system from which the selected codes come from.
749         */
750        public ConceptSetComponent setSystem(String value) { 
751          if (Utilities.noString(value))
752            this.system = null;
753          else {
754            if (this.system == null)
755              this.system = new UriType();
756            this.system.setValue(value);
757          }
758          return this;
759        }
760
761        /**
762         * @return {@link #version} (The version of the code system that the codes are selected from.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
763         */
764        public StringType getVersionElement() { 
765          if (this.version == null)
766            if (Configuration.errorOnAutoCreate())
767              throw new Error("Attempt to auto-create ConceptSetComponent.version");
768            else if (Configuration.doAutoCreate())
769              this.version = new StringType(); // bb
770          return this.version;
771        }
772
773        public boolean hasVersionElement() { 
774          return this.version != null && !this.version.isEmpty();
775        }
776
777        public boolean hasVersion() { 
778          return this.version != null && !this.version.isEmpty();
779        }
780
781        /**
782         * @param value {@link #version} (The version of the code system that the codes are selected from.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
783         */
784        public ConceptSetComponent setVersionElement(StringType value) { 
785          this.version = value;
786          return this;
787        }
788
789        /**
790         * @return The version of the code system that the codes are selected from.
791         */
792        public String getVersion() { 
793          return this.version == null ? null : this.version.getValue();
794        }
795
796        /**
797         * @param value The version of the code system that the codes are selected from.
798         */
799        public ConceptSetComponent setVersion(String value) { 
800          if (Utilities.noString(value))
801            this.version = null;
802          else {
803            if (this.version == null)
804              this.version = new StringType();
805            this.version.setValue(value);
806          }
807          return this;
808        }
809
810        /**
811         * @return {@link #concept} (Specifies a concept to be included or excluded.)
812         */
813        public List<ConceptReferenceComponent> getConcept() { 
814          if (this.concept == null)
815            this.concept = new ArrayList<ConceptReferenceComponent>();
816          return this.concept;
817        }
818
819        /**
820         * @return Returns a reference to <code>this</code> for easy method chaining
821         */
822        public ConceptSetComponent setConcept(List<ConceptReferenceComponent> theConcept) { 
823          this.concept = theConcept;
824          return this;
825        }
826
827        public boolean hasConcept() { 
828          if (this.concept == null)
829            return false;
830          for (ConceptReferenceComponent item : this.concept)
831            if (!item.isEmpty())
832              return true;
833          return false;
834        }
835
836        public ConceptReferenceComponent addConcept() { //3
837          ConceptReferenceComponent t = new ConceptReferenceComponent();
838          if (this.concept == null)
839            this.concept = new ArrayList<ConceptReferenceComponent>();
840          this.concept.add(t);
841          return t;
842        }
843
844        public ConceptSetComponent addConcept(ConceptReferenceComponent t) { //3
845          if (t == null)
846            return this;
847          if (this.concept == null)
848            this.concept = new ArrayList<ConceptReferenceComponent>();
849          this.concept.add(t);
850          return this;
851        }
852
853        /**
854         * @return The first repetition of repeating field {@link #concept}, creating it if it does not already exist
855         */
856        public ConceptReferenceComponent getConceptFirstRep() { 
857          if (getConcept().isEmpty()) {
858            addConcept();
859          }
860          return getConcept().get(0);
861        }
862
863        /**
864         * @return {@link #filter} (Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.)
865         */
866        public List<ConceptSetFilterComponent> getFilter() { 
867          if (this.filter == null)
868            this.filter = new ArrayList<ConceptSetFilterComponent>();
869          return this.filter;
870        }
871
872        /**
873         * @return Returns a reference to <code>this</code> for easy method chaining
874         */
875        public ConceptSetComponent setFilter(List<ConceptSetFilterComponent> theFilter) { 
876          this.filter = theFilter;
877          return this;
878        }
879
880        public boolean hasFilter() { 
881          if (this.filter == null)
882            return false;
883          for (ConceptSetFilterComponent item : this.filter)
884            if (!item.isEmpty())
885              return true;
886          return false;
887        }
888
889        public ConceptSetFilterComponent addFilter() { //3
890          ConceptSetFilterComponent t = new ConceptSetFilterComponent();
891          if (this.filter == null)
892            this.filter = new ArrayList<ConceptSetFilterComponent>();
893          this.filter.add(t);
894          return t;
895        }
896
897        public ConceptSetComponent addFilter(ConceptSetFilterComponent t) { //3
898          if (t == null)
899            return this;
900          if (this.filter == null)
901            this.filter = new ArrayList<ConceptSetFilterComponent>();
902          this.filter.add(t);
903          return this;
904        }
905
906        /**
907         * @return The first repetition of repeating field {@link #filter}, creating it if it does not already exist
908         */
909        public ConceptSetFilterComponent getFilterFirstRep() { 
910          if (getFilter().isEmpty()) {
911            addFilter();
912          }
913          return getFilter().get(0);
914        }
915
916        /**
917         * @return {@link #valueSet} (Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.)
918         */
919        public List<UriType> getValueSet() { 
920          if (this.valueSet == null)
921            this.valueSet = new ArrayList<UriType>();
922          return this.valueSet;
923        }
924
925        /**
926         * @return Returns a reference to <code>this</code> for easy method chaining
927         */
928        public ConceptSetComponent setValueSet(List<UriType> theValueSet) { 
929          this.valueSet = theValueSet;
930          return this;
931        }
932
933        public boolean hasValueSet() { 
934          if (this.valueSet == null)
935            return false;
936          for (UriType item : this.valueSet)
937            if (!item.isEmpty())
938              return true;
939          return false;
940        }
941
942        /**
943         * @return {@link #valueSet} (Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.)
944         */
945        public UriType addValueSetElement() {//2 
946          UriType t = new UriType();
947          if (this.valueSet == null)
948            this.valueSet = new ArrayList<UriType>();
949          this.valueSet.add(t);
950          return t;
951        }
952
953        /**
954         * @param value {@link #valueSet} (Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.)
955         */
956        public ConceptSetComponent addValueSet(String value) { //1
957          UriType t = new UriType();
958          t.setValue(value);
959          if (this.valueSet == null)
960            this.valueSet = new ArrayList<UriType>();
961          this.valueSet.add(t);
962          return this;
963        }
964
965        /**
966         * @param value {@link #valueSet} (Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.)
967         */
968        public boolean hasValueSet(String value) { 
969          if (this.valueSet == null)
970            return false;
971          for (UriType v : this.valueSet)
972            if (v.getValue().equals(value)) // uri
973              return true;
974          return false;
975        }
976
977        protected void listChildren(List<Property> children) {
978          super.listChildren(children);
979          children.add(new Property("system", "uri", "An absolute URI which is the code system from which the selected codes come from.", 0, 1, system));
980          children.add(new Property("version", "string", "The version of the code system that the codes are selected from.", 0, 1, version));
981          children.add(new Property("concept", "", "Specifies a concept to be included or excluded.", 0, java.lang.Integer.MAX_VALUE, concept));
982          children.add(new Property("filter", "", "Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.", 0, java.lang.Integer.MAX_VALUE, filter));
983          children.add(new Property("valueSet", "uri", "Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.", 0, java.lang.Integer.MAX_VALUE, valueSet));
984        }
985
986        @Override
987        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
988          switch (_hash) {
989          case -887328209: /*system*/  return new Property("system", "uri", "An absolute URI which is the code system from which the selected codes come from.", 0, 1, system);
990          case 351608024: /*version*/  return new Property("version", "string", "The version of the code system that the codes are selected from.", 0, 1, version);
991          case 951024232: /*concept*/  return new Property("concept", "", "Specifies a concept to be included or excluded.", 0, java.lang.Integer.MAX_VALUE, concept);
992          case -1274492040: /*filter*/  return new Property("filter", "", "Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.", 0, java.lang.Integer.MAX_VALUE, filter);
993          case -1410174671: /*valueSet*/  return new Property("valueSet", "uri", "Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.", 0, java.lang.Integer.MAX_VALUE, valueSet);
994          default: return super.getNamedProperty(_hash, _name, _checkValid);
995          }
996
997        }
998
999      @Override
1000      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1001        switch (hash) {
1002        case -887328209: /*system*/ return this.system == null ? new Base[0] : new Base[] {this.system}; // UriType
1003        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
1004        case 951024232: /*concept*/ return this.concept == null ? new Base[0] : this.concept.toArray(new Base[this.concept.size()]); // ConceptReferenceComponent
1005        case -1274492040: /*filter*/ return this.filter == null ? new Base[0] : this.filter.toArray(new Base[this.filter.size()]); // ConceptSetFilterComponent
1006        case -1410174671: /*valueSet*/ return this.valueSet == null ? new Base[0] : this.valueSet.toArray(new Base[this.valueSet.size()]); // UriType
1007        default: return super.getProperty(hash, name, checkValid);
1008        }
1009
1010      }
1011
1012      @Override
1013      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1014        switch (hash) {
1015        case -887328209: // system
1016          this.system = castToUri(value); // UriType
1017          return value;
1018        case 351608024: // version
1019          this.version = castToString(value); // StringType
1020          return value;
1021        case 951024232: // concept
1022          this.getConcept().add((ConceptReferenceComponent) value); // ConceptReferenceComponent
1023          return value;
1024        case -1274492040: // filter
1025          this.getFilter().add((ConceptSetFilterComponent) value); // ConceptSetFilterComponent
1026          return value;
1027        case -1410174671: // valueSet
1028          this.getValueSet().add(castToUri(value)); // UriType
1029          return value;
1030        default: return super.setProperty(hash, name, value);
1031        }
1032
1033      }
1034
1035      @Override
1036      public Base setProperty(String name, Base value) throws FHIRException {
1037        if (name.equals("system")) {
1038          this.system = castToUri(value); // UriType
1039        } else if (name.equals("version")) {
1040          this.version = castToString(value); // StringType
1041        } else if (name.equals("concept")) {
1042          this.getConcept().add((ConceptReferenceComponent) value);
1043        } else if (name.equals("filter")) {
1044          this.getFilter().add((ConceptSetFilterComponent) value);
1045        } else if (name.equals("valueSet")) {
1046          this.getValueSet().add(castToUri(value));
1047        } else
1048          return super.setProperty(name, value);
1049        return value;
1050      }
1051
1052      @Override
1053      public Base makeProperty(int hash, String name) throws FHIRException {
1054        switch (hash) {
1055        case -887328209:  return getSystemElement();
1056        case 351608024:  return getVersionElement();
1057        case 951024232:  return addConcept(); 
1058        case -1274492040:  return addFilter(); 
1059        case -1410174671:  return addValueSetElement();
1060        default: return super.makeProperty(hash, name);
1061        }
1062
1063      }
1064
1065      @Override
1066      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1067        switch (hash) {
1068        case -887328209: /*system*/ return new String[] {"uri"};
1069        case 351608024: /*version*/ return new String[] {"string"};
1070        case 951024232: /*concept*/ return new String[] {};
1071        case -1274492040: /*filter*/ return new String[] {};
1072        case -1410174671: /*valueSet*/ return new String[] {"uri"};
1073        default: return super.getTypesForProperty(hash, name);
1074        }
1075
1076      }
1077
1078      @Override
1079      public Base addChild(String name) throws FHIRException {
1080        if (name.equals("system")) {
1081          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.system");
1082        }
1083        else if (name.equals("version")) {
1084          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.version");
1085        }
1086        else if (name.equals("concept")) {
1087          return addConcept();
1088        }
1089        else if (name.equals("filter")) {
1090          return addFilter();
1091        }
1092        else if (name.equals("valueSet")) {
1093          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.valueSet");
1094        }
1095        else
1096          return super.addChild(name);
1097      }
1098
1099      public ConceptSetComponent copy() {
1100        ConceptSetComponent dst = new ConceptSetComponent();
1101        copyValues(dst);
1102        dst.system = system == null ? null : system.copy();
1103        dst.version = version == null ? null : version.copy();
1104        if (concept != null) {
1105          dst.concept = new ArrayList<ConceptReferenceComponent>();
1106          for (ConceptReferenceComponent i : concept)
1107            dst.concept.add(i.copy());
1108        };
1109        if (filter != null) {
1110          dst.filter = new ArrayList<ConceptSetFilterComponent>();
1111          for (ConceptSetFilterComponent i : filter)
1112            dst.filter.add(i.copy());
1113        };
1114        if (valueSet != null) {
1115          dst.valueSet = new ArrayList<UriType>();
1116          for (UriType i : valueSet)
1117            dst.valueSet.add(i.copy());
1118        };
1119        return dst;
1120      }
1121
1122      @Override
1123      public boolean equalsDeep(Base other_) {
1124        if (!super.equalsDeep(other_))
1125          return false;
1126        if (!(other_ instanceof ConceptSetComponent))
1127          return false;
1128        ConceptSetComponent o = (ConceptSetComponent) other_;
1129        return compareDeep(system, o.system, true) && compareDeep(version, o.version, true) && compareDeep(concept, o.concept, true)
1130           && compareDeep(filter, o.filter, true) && compareDeep(valueSet, o.valueSet, true);
1131      }
1132
1133      @Override
1134      public boolean equalsShallow(Base other_) {
1135        if (!super.equalsShallow(other_))
1136          return false;
1137        if (!(other_ instanceof ConceptSetComponent))
1138          return false;
1139        ConceptSetComponent o = (ConceptSetComponent) other_;
1140        return compareValues(system, o.system, true) && compareValues(version, o.version, true) && compareValues(valueSet, o.valueSet, true)
1141          ;
1142      }
1143
1144      public boolean isEmpty() {
1145        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(system, version, concept
1146          , filter, valueSet);
1147      }
1148
1149  public String fhirType() {
1150    return "ValueSet.compose.include";
1151
1152  }
1153
1154  }
1155
1156    @Block()
1157    public static class ConceptReferenceComponent extends BackboneElement implements IBaseBackboneElement {
1158        /**
1159         * Specifies a code for the concept to be included or excluded.
1160         */
1161        @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
1162        @Description(shortDefinition="Code or expression from system", formalDefinition="Specifies a code for the concept to be included or excluded." )
1163        protected CodeType code;
1164
1165        /**
1166         * The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.
1167         */
1168        @Child(name = "display", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1169        @Description(shortDefinition="Text to display for this code for this value set in this valueset", formalDefinition="The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system." )
1170        protected StringType display;
1171
1172        /**
1173         * Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.
1174         */
1175        @Child(name = "designation", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1176        @Description(shortDefinition="Additional representations for this concept", formalDefinition="Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc." )
1177        protected List<ConceptReferenceDesignationComponent> designation;
1178
1179        private static final long serialVersionUID = 260579971L;
1180
1181    /**
1182     * Constructor
1183     */
1184      public ConceptReferenceComponent() {
1185        super();
1186      }
1187
1188    /**
1189     * Constructor
1190     */
1191      public ConceptReferenceComponent(CodeType code) {
1192        super();
1193        this.code = code;
1194      }
1195
1196        /**
1197         * @return {@link #code} (Specifies a code for the concept to be included or excluded.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1198         */
1199        public CodeType getCodeElement() { 
1200          if (this.code == null)
1201            if (Configuration.errorOnAutoCreate())
1202              throw new Error("Attempt to auto-create ConceptReferenceComponent.code");
1203            else if (Configuration.doAutoCreate())
1204              this.code = new CodeType(); // bb
1205          return this.code;
1206        }
1207
1208        public boolean hasCodeElement() { 
1209          return this.code != null && !this.code.isEmpty();
1210        }
1211
1212        public boolean hasCode() { 
1213          return this.code != null && !this.code.isEmpty();
1214        }
1215
1216        /**
1217         * @param value {@link #code} (Specifies a code for the concept to be included or excluded.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1218         */
1219        public ConceptReferenceComponent setCodeElement(CodeType value) { 
1220          this.code = value;
1221          return this;
1222        }
1223
1224        /**
1225         * @return Specifies a code for the concept to be included or excluded.
1226         */
1227        public String getCode() { 
1228          return this.code == null ? null : this.code.getValue();
1229        }
1230
1231        /**
1232         * @param value Specifies a code for the concept to be included or excluded.
1233         */
1234        public ConceptReferenceComponent setCode(String value) { 
1235            if (this.code == null)
1236              this.code = new CodeType();
1237            this.code.setValue(value);
1238          return this;
1239        }
1240
1241        /**
1242         * @return {@link #display} (The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
1243         */
1244        public StringType getDisplayElement() { 
1245          if (this.display == null)
1246            if (Configuration.errorOnAutoCreate())
1247              throw new Error("Attempt to auto-create ConceptReferenceComponent.display");
1248            else if (Configuration.doAutoCreate())
1249              this.display = new StringType(); // bb
1250          return this.display;
1251        }
1252
1253        public boolean hasDisplayElement() { 
1254          return this.display != null && !this.display.isEmpty();
1255        }
1256
1257        public boolean hasDisplay() { 
1258          return this.display != null && !this.display.isEmpty();
1259        }
1260
1261        /**
1262         * @param value {@link #display} (The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
1263         */
1264        public ConceptReferenceComponent setDisplayElement(StringType value) { 
1265          this.display = value;
1266          return this;
1267        }
1268
1269        /**
1270         * @return The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.
1271         */
1272        public String getDisplay() { 
1273          return this.display == null ? null : this.display.getValue();
1274        }
1275
1276        /**
1277         * @param value The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.
1278         */
1279        public ConceptReferenceComponent setDisplay(String value) { 
1280          if (Utilities.noString(value))
1281            this.display = null;
1282          else {
1283            if (this.display == null)
1284              this.display = new StringType();
1285            this.display.setValue(value);
1286          }
1287          return this;
1288        }
1289
1290        /**
1291         * @return {@link #designation} (Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.)
1292         */
1293        public List<ConceptReferenceDesignationComponent> getDesignation() { 
1294          if (this.designation == null)
1295            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
1296          return this.designation;
1297        }
1298
1299        /**
1300         * @return Returns a reference to <code>this</code> for easy method chaining
1301         */
1302        public ConceptReferenceComponent setDesignation(List<ConceptReferenceDesignationComponent> theDesignation) { 
1303          this.designation = theDesignation;
1304          return this;
1305        }
1306
1307        public boolean hasDesignation() { 
1308          if (this.designation == null)
1309            return false;
1310          for (ConceptReferenceDesignationComponent item : this.designation)
1311            if (!item.isEmpty())
1312              return true;
1313          return false;
1314        }
1315
1316        public ConceptReferenceDesignationComponent addDesignation() { //3
1317          ConceptReferenceDesignationComponent t = new ConceptReferenceDesignationComponent();
1318          if (this.designation == null)
1319            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
1320          this.designation.add(t);
1321          return t;
1322        }
1323
1324        public ConceptReferenceComponent addDesignation(ConceptReferenceDesignationComponent t) { //3
1325          if (t == null)
1326            return this;
1327          if (this.designation == null)
1328            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
1329          this.designation.add(t);
1330          return this;
1331        }
1332
1333        /**
1334         * @return The first repetition of repeating field {@link #designation}, creating it if it does not already exist
1335         */
1336        public ConceptReferenceDesignationComponent getDesignationFirstRep() { 
1337          if (getDesignation().isEmpty()) {
1338            addDesignation();
1339          }
1340          return getDesignation().get(0);
1341        }
1342
1343        protected void listChildren(List<Property> children) {
1344          super.listChildren(children);
1345          children.add(new Property("code", "code", "Specifies a code for the concept to be included or excluded.", 0, 1, code));
1346          children.add(new Property("display", "string", "The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.", 0, 1, display));
1347          children.add(new Property("designation", "", "Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.", 0, java.lang.Integer.MAX_VALUE, designation));
1348        }
1349
1350        @Override
1351        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1352          switch (_hash) {
1353          case 3059181: /*code*/  return new Property("code", "code", "Specifies a code for the concept to be included or excluded.", 0, 1, code);
1354          case 1671764162: /*display*/  return new Property("display", "string", "The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.", 0, 1, display);
1355          case -900931593: /*designation*/  return new Property("designation", "", "Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.", 0, java.lang.Integer.MAX_VALUE, designation);
1356          default: return super.getNamedProperty(_hash, _name, _checkValid);
1357          }
1358
1359        }
1360
1361      @Override
1362      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1363        switch (hash) {
1364        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType
1365        case 1671764162: /*display*/ return this.display == null ? new Base[0] : new Base[] {this.display}; // StringType
1366        case -900931593: /*designation*/ return this.designation == null ? new Base[0] : this.designation.toArray(new Base[this.designation.size()]); // ConceptReferenceDesignationComponent
1367        default: return super.getProperty(hash, name, checkValid);
1368        }
1369
1370      }
1371
1372      @Override
1373      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1374        switch (hash) {
1375        case 3059181: // code
1376          this.code = castToCode(value); // CodeType
1377          return value;
1378        case 1671764162: // display
1379          this.display = castToString(value); // StringType
1380          return value;
1381        case -900931593: // designation
1382          this.getDesignation().add((ConceptReferenceDesignationComponent) value); // ConceptReferenceDesignationComponent
1383          return value;
1384        default: return super.setProperty(hash, name, value);
1385        }
1386
1387      }
1388
1389      @Override
1390      public Base setProperty(String name, Base value) throws FHIRException {
1391        if (name.equals("code")) {
1392          this.code = castToCode(value); // CodeType
1393        } else if (name.equals("display")) {
1394          this.display = castToString(value); // StringType
1395        } else if (name.equals("designation")) {
1396          this.getDesignation().add((ConceptReferenceDesignationComponent) value);
1397        } else
1398          return super.setProperty(name, value);
1399        return value;
1400      }
1401
1402      @Override
1403      public Base makeProperty(int hash, String name) throws FHIRException {
1404        switch (hash) {
1405        case 3059181:  return getCodeElement();
1406        case 1671764162:  return getDisplayElement();
1407        case -900931593:  return addDesignation(); 
1408        default: return super.makeProperty(hash, name);
1409        }
1410
1411      }
1412
1413      @Override
1414      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1415        switch (hash) {
1416        case 3059181: /*code*/ return new String[] {"code"};
1417        case 1671764162: /*display*/ return new String[] {"string"};
1418        case -900931593: /*designation*/ return new String[] {};
1419        default: return super.getTypesForProperty(hash, name);
1420        }
1421
1422      }
1423
1424      @Override
1425      public Base addChild(String name) throws FHIRException {
1426        if (name.equals("code")) {
1427          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.code");
1428        }
1429        else if (name.equals("display")) {
1430          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.display");
1431        }
1432        else if (name.equals("designation")) {
1433          return addDesignation();
1434        }
1435        else
1436          return super.addChild(name);
1437      }
1438
1439      public ConceptReferenceComponent copy() {
1440        ConceptReferenceComponent dst = new ConceptReferenceComponent();
1441        copyValues(dst);
1442        dst.code = code == null ? null : code.copy();
1443        dst.display = display == null ? null : display.copy();
1444        if (designation != null) {
1445          dst.designation = new ArrayList<ConceptReferenceDesignationComponent>();
1446          for (ConceptReferenceDesignationComponent i : designation)
1447            dst.designation.add(i.copy());
1448        };
1449        return dst;
1450      }
1451
1452      @Override
1453      public boolean equalsDeep(Base other_) {
1454        if (!super.equalsDeep(other_))
1455          return false;
1456        if (!(other_ instanceof ConceptReferenceComponent))
1457          return false;
1458        ConceptReferenceComponent o = (ConceptReferenceComponent) other_;
1459        return compareDeep(code, o.code, true) && compareDeep(display, o.display, true) && compareDeep(designation, o.designation, true)
1460          ;
1461      }
1462
1463      @Override
1464      public boolean equalsShallow(Base other_) {
1465        if (!super.equalsShallow(other_))
1466          return false;
1467        if (!(other_ instanceof ConceptReferenceComponent))
1468          return false;
1469        ConceptReferenceComponent o = (ConceptReferenceComponent) other_;
1470        return compareValues(code, o.code, true) && compareValues(display, o.display, true);
1471      }
1472
1473      public boolean isEmpty() {
1474        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, display, designation
1475          );
1476      }
1477
1478  public String fhirType() {
1479    return "ValueSet.compose.include.concept";
1480
1481  }
1482
1483  }
1484
1485    @Block()
1486    public static class ConceptReferenceDesignationComponent extends BackboneElement implements IBaseBackboneElement {
1487        /**
1488         * The language this designation is defined for.
1489         */
1490        @Child(name = "language", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=false)
1491        @Description(shortDefinition="Human language of the designation", formalDefinition="The language this designation is defined for." )
1492        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/languages")
1493        protected CodeType language;
1494
1495        /**
1496         * A code that details how this designation would be used.
1497         */
1498        @Child(name = "use", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
1499        @Description(shortDefinition="Details how this designation would be used", formalDefinition="A code that details how this designation would be used." )
1500        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/designation-use")
1501        protected Coding use;
1502
1503        /**
1504         * The text value for this designation.
1505         */
1506        @Child(name = "value", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=false)
1507        @Description(shortDefinition="The text value for this designation", formalDefinition="The text value for this designation." )
1508        protected StringType value;
1509
1510        private static final long serialVersionUID = 1515662414L;
1511
1512    /**
1513     * Constructor
1514     */
1515      public ConceptReferenceDesignationComponent() {
1516        super();
1517      }
1518
1519    /**
1520     * Constructor
1521     */
1522      public ConceptReferenceDesignationComponent(StringType value) {
1523        super();
1524        this.value = value;
1525      }
1526
1527        /**
1528         * @return {@link #language} (The language this designation is defined for.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
1529         */
1530        public CodeType getLanguageElement() { 
1531          if (this.language == null)
1532            if (Configuration.errorOnAutoCreate())
1533              throw new Error("Attempt to auto-create ConceptReferenceDesignationComponent.language");
1534            else if (Configuration.doAutoCreate())
1535              this.language = new CodeType(); // bb
1536          return this.language;
1537        }
1538
1539        public boolean hasLanguageElement() { 
1540          return this.language != null && !this.language.isEmpty();
1541        }
1542
1543        public boolean hasLanguage() { 
1544          return this.language != null && !this.language.isEmpty();
1545        }
1546
1547        /**
1548         * @param value {@link #language} (The language this designation is defined for.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
1549         */
1550        public ConceptReferenceDesignationComponent setLanguageElement(CodeType value) { 
1551          this.language = value;
1552          return this;
1553        }
1554
1555        /**
1556         * @return The language this designation is defined for.
1557         */
1558        public String getLanguage() { 
1559          return this.language == null ? null : this.language.getValue();
1560        }
1561
1562        /**
1563         * @param value The language this designation is defined for.
1564         */
1565        public ConceptReferenceDesignationComponent setLanguage(String value) { 
1566          if (Utilities.noString(value))
1567            this.language = null;
1568          else {
1569            if (this.language == null)
1570              this.language = new CodeType();
1571            this.language.setValue(value);
1572          }
1573          return this;
1574        }
1575
1576        /**
1577         * @return {@link #use} (A code that details how this designation would be used.)
1578         */
1579        public Coding getUse() { 
1580          if (this.use == null)
1581            if (Configuration.errorOnAutoCreate())
1582              throw new Error("Attempt to auto-create ConceptReferenceDesignationComponent.use");
1583            else if (Configuration.doAutoCreate())
1584              this.use = new Coding(); // cc
1585          return this.use;
1586        }
1587
1588        public boolean hasUse() { 
1589          return this.use != null && !this.use.isEmpty();
1590        }
1591
1592        /**
1593         * @param value {@link #use} (A code that details how this designation would be used.)
1594         */
1595        public ConceptReferenceDesignationComponent setUse(Coding value)  { 
1596          this.use = value;
1597          return this;
1598        }
1599
1600        /**
1601         * @return {@link #value} (The text value for this designation.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1602         */
1603        public StringType getValueElement() { 
1604          if (this.value == null)
1605            if (Configuration.errorOnAutoCreate())
1606              throw new Error("Attempt to auto-create ConceptReferenceDesignationComponent.value");
1607            else if (Configuration.doAutoCreate())
1608              this.value = new StringType(); // bb
1609          return this.value;
1610        }
1611
1612        public boolean hasValueElement() { 
1613          return this.value != null && !this.value.isEmpty();
1614        }
1615
1616        public boolean hasValue() { 
1617          return this.value != null && !this.value.isEmpty();
1618        }
1619
1620        /**
1621         * @param value {@link #value} (The text value for this designation.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1622         */
1623        public ConceptReferenceDesignationComponent setValueElement(StringType value) { 
1624          this.value = value;
1625          return this;
1626        }
1627
1628        /**
1629         * @return The text value for this designation.
1630         */
1631        public String getValue() { 
1632          return this.value == null ? null : this.value.getValue();
1633        }
1634
1635        /**
1636         * @param value The text value for this designation.
1637         */
1638        public ConceptReferenceDesignationComponent setValue(String value) { 
1639            if (this.value == null)
1640              this.value = new StringType();
1641            this.value.setValue(value);
1642          return this;
1643        }
1644
1645        protected void listChildren(List<Property> children) {
1646          super.listChildren(children);
1647          children.add(new Property("language", "code", "The language this designation is defined for.", 0, 1, language));
1648          children.add(new Property("use", "Coding", "A code that details how this designation would be used.", 0, 1, use));
1649          children.add(new Property("value", "string", "The text value for this designation.", 0, 1, value));
1650        }
1651
1652        @Override
1653        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1654          switch (_hash) {
1655          case -1613589672: /*language*/  return new Property("language", "code", "The language this designation is defined for.", 0, 1, language);
1656          case 116103: /*use*/  return new Property("use", "Coding", "A code that details how this designation would be used.", 0, 1, use);
1657          case 111972721: /*value*/  return new Property("value", "string", "The text value for this designation.", 0, 1, value);
1658          default: return super.getNamedProperty(_hash, _name, _checkValid);
1659          }
1660
1661        }
1662
1663      @Override
1664      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1665        switch (hash) {
1666        case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // CodeType
1667        case 116103: /*use*/ return this.use == null ? new Base[0] : new Base[] {this.use}; // Coding
1668        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType
1669        default: return super.getProperty(hash, name, checkValid);
1670        }
1671
1672      }
1673
1674      @Override
1675      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1676        switch (hash) {
1677        case -1613589672: // language
1678          this.language = castToCode(value); // CodeType
1679          return value;
1680        case 116103: // use
1681          this.use = castToCoding(value); // Coding
1682          return value;
1683        case 111972721: // value
1684          this.value = castToString(value); // StringType
1685          return value;
1686        default: return super.setProperty(hash, name, value);
1687        }
1688
1689      }
1690
1691      @Override
1692      public Base setProperty(String name, Base value) throws FHIRException {
1693        if (name.equals("language")) {
1694          this.language = castToCode(value); // CodeType
1695        } else if (name.equals("use")) {
1696          this.use = castToCoding(value); // Coding
1697        } else if (name.equals("value")) {
1698          this.value = castToString(value); // StringType
1699        } else
1700          return super.setProperty(name, value);
1701        return value;
1702      }
1703
1704      @Override
1705      public Base makeProperty(int hash, String name) throws FHIRException {
1706        switch (hash) {
1707        case -1613589672:  return getLanguageElement();
1708        case 116103:  return getUse(); 
1709        case 111972721:  return getValueElement();
1710        default: return super.makeProperty(hash, name);
1711        }
1712
1713      }
1714
1715      @Override
1716      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1717        switch (hash) {
1718        case -1613589672: /*language*/ return new String[] {"code"};
1719        case 116103: /*use*/ return new String[] {"Coding"};
1720        case 111972721: /*value*/ return new String[] {"string"};
1721        default: return super.getTypesForProperty(hash, name);
1722        }
1723
1724      }
1725
1726      @Override
1727      public Base addChild(String name) throws FHIRException {
1728        if (name.equals("language")) {
1729          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.language");
1730        }
1731        else if (name.equals("use")) {
1732          this.use = new Coding();
1733          return this.use;
1734        }
1735        else if (name.equals("value")) {
1736          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.value");
1737        }
1738        else
1739          return super.addChild(name);
1740      }
1741
1742      public ConceptReferenceDesignationComponent copy() {
1743        ConceptReferenceDesignationComponent dst = new ConceptReferenceDesignationComponent();
1744        copyValues(dst);
1745        dst.language = language == null ? null : language.copy();
1746        dst.use = use == null ? null : use.copy();
1747        dst.value = value == null ? null : value.copy();
1748        return dst;
1749      }
1750
1751      @Override
1752      public boolean equalsDeep(Base other_) {
1753        if (!super.equalsDeep(other_))
1754          return false;
1755        if (!(other_ instanceof ConceptReferenceDesignationComponent))
1756          return false;
1757        ConceptReferenceDesignationComponent o = (ConceptReferenceDesignationComponent) other_;
1758        return compareDeep(language, o.language, true) && compareDeep(use, o.use, true) && compareDeep(value, o.value, true)
1759          ;
1760      }
1761
1762      @Override
1763      public boolean equalsShallow(Base other_) {
1764        if (!super.equalsShallow(other_))
1765          return false;
1766        if (!(other_ instanceof ConceptReferenceDesignationComponent))
1767          return false;
1768        ConceptReferenceDesignationComponent o = (ConceptReferenceDesignationComponent) other_;
1769        return compareValues(language, o.language, true) && compareValues(value, o.value, true);
1770      }
1771
1772      public boolean isEmpty() {
1773        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(language, use, value);
1774      }
1775
1776  public String fhirType() {
1777    return "ValueSet.compose.include.concept.designation";
1778
1779  }
1780
1781  }
1782
1783    @Block()
1784    public static class ConceptSetFilterComponent extends BackboneElement implements IBaseBackboneElement {
1785        /**
1786         * A code that identifies a property defined in the code system.
1787         */
1788        @Child(name = "property", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1789        @Description(shortDefinition="A property defined by the code system", formalDefinition="A code that identifies a property defined in the code system." )
1790        protected CodeType property;
1791
1792        /**
1793         * The kind of operation to perform as a part of the filter criteria.
1794         */
1795        @Child(name = "op", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true)
1796        @Description(shortDefinition="= | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists", formalDefinition="The kind of operation to perform as a part of the filter criteria." )
1797        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/filter-operator")
1798        protected Enumeration<FilterOperator> op;
1799
1800        /**
1801         * The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.
1802         */
1803        @Child(name = "value", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
1804        @Description(shortDefinition="Code from the system, or regex criteria, or boolean value for exists", formalDefinition="The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'." )
1805        protected CodeType value;
1806
1807        private static final long serialVersionUID = 1985515000L;
1808
1809    /**
1810     * Constructor
1811     */
1812      public ConceptSetFilterComponent() {
1813        super();
1814      }
1815
1816    /**
1817     * Constructor
1818     */
1819      public ConceptSetFilterComponent(CodeType property, Enumeration<FilterOperator> op, CodeType value) {
1820        super();
1821        this.property = property;
1822        this.op = op;
1823        this.value = value;
1824      }
1825
1826        /**
1827         * @return {@link #property} (A code that identifies a property defined in the code system.). This is the underlying object with id, value and extensions. The accessor "getProperty" gives direct access to the value
1828         */
1829        public CodeType getPropertyElement() { 
1830          if (this.property == null)
1831            if (Configuration.errorOnAutoCreate())
1832              throw new Error("Attempt to auto-create ConceptSetFilterComponent.property");
1833            else if (Configuration.doAutoCreate())
1834              this.property = new CodeType(); // bb
1835          return this.property;
1836        }
1837
1838        public boolean hasPropertyElement() { 
1839          return this.property != null && !this.property.isEmpty();
1840        }
1841
1842        public boolean hasProperty() { 
1843          return this.property != null && !this.property.isEmpty();
1844        }
1845
1846        /**
1847         * @param value {@link #property} (A code that identifies a property defined in the code system.). This is the underlying object with id, value and extensions. The accessor "getProperty" gives direct access to the value
1848         */
1849        public ConceptSetFilterComponent setPropertyElement(CodeType value) { 
1850          this.property = value;
1851          return this;
1852        }
1853
1854        /**
1855         * @return A code that identifies a property defined in the code system.
1856         */
1857        public String getProperty() { 
1858          return this.property == null ? null : this.property.getValue();
1859        }
1860
1861        /**
1862         * @param value A code that identifies a property defined in the code system.
1863         */
1864        public ConceptSetFilterComponent setProperty(String value) { 
1865            if (this.property == null)
1866              this.property = new CodeType();
1867            this.property.setValue(value);
1868          return this;
1869        }
1870
1871        /**
1872         * @return {@link #op} (The kind of operation to perform as a part of the filter criteria.). This is the underlying object with id, value and extensions. The accessor "getOp" gives direct access to the value
1873         */
1874        public Enumeration<FilterOperator> getOpElement() { 
1875          if (this.op == null)
1876            if (Configuration.errorOnAutoCreate())
1877              throw new Error("Attempt to auto-create ConceptSetFilterComponent.op");
1878            else if (Configuration.doAutoCreate())
1879              this.op = new Enumeration<FilterOperator>(new FilterOperatorEnumFactory()); // bb
1880          return this.op;
1881        }
1882
1883        public boolean hasOpElement() { 
1884          return this.op != null && !this.op.isEmpty();
1885        }
1886
1887        public boolean hasOp() { 
1888          return this.op != null && !this.op.isEmpty();
1889        }
1890
1891        /**
1892         * @param value {@link #op} (The kind of operation to perform as a part of the filter criteria.). This is the underlying object with id, value and extensions. The accessor "getOp" gives direct access to the value
1893         */
1894        public ConceptSetFilterComponent setOpElement(Enumeration<FilterOperator> value) { 
1895          this.op = value;
1896          return this;
1897        }
1898
1899        /**
1900         * @return The kind of operation to perform as a part of the filter criteria.
1901         */
1902        public FilterOperator getOp() { 
1903          return this.op == null ? null : this.op.getValue();
1904        }
1905
1906        /**
1907         * @param value The kind of operation to perform as a part of the filter criteria.
1908         */
1909        public ConceptSetFilterComponent setOp(FilterOperator value) { 
1910            if (this.op == null)
1911              this.op = new Enumeration<FilterOperator>(new FilterOperatorEnumFactory());
1912            this.op.setValue(value);
1913          return this;
1914        }
1915
1916        /**
1917         * @return {@link #value} (The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1918         */
1919        public CodeType getValueElement() { 
1920          if (this.value == null)
1921            if (Configuration.errorOnAutoCreate())
1922              throw new Error("Attempt to auto-create ConceptSetFilterComponent.value");
1923            else if (Configuration.doAutoCreate())
1924              this.value = new CodeType(); // bb
1925          return this.value;
1926        }
1927
1928        public boolean hasValueElement() { 
1929          return this.value != null && !this.value.isEmpty();
1930        }
1931
1932        public boolean hasValue() { 
1933          return this.value != null && !this.value.isEmpty();
1934        }
1935
1936        /**
1937         * @param value {@link #value} (The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1938         */
1939        public ConceptSetFilterComponent setValueElement(CodeType value) { 
1940          this.value = value;
1941          return this;
1942        }
1943
1944        /**
1945         * @return The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.
1946         */
1947        public String getValue() { 
1948          return this.value == null ? null : this.value.getValue();
1949        }
1950
1951        /**
1952         * @param value The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.
1953         */
1954        public ConceptSetFilterComponent setValue(String value) { 
1955            if (this.value == null)
1956              this.value = new CodeType();
1957            this.value.setValue(value);
1958          return this;
1959        }
1960
1961        protected void listChildren(List<Property> children) {
1962          super.listChildren(children);
1963          children.add(new Property("property", "code", "A code that identifies a property defined in the code system.", 0, 1, property));
1964          children.add(new Property("op", "code", "The kind of operation to perform as a part of the filter criteria.", 0, 1, op));
1965          children.add(new Property("value", "code", "The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.", 0, 1, value));
1966        }
1967
1968        @Override
1969        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1970          switch (_hash) {
1971          case -993141291: /*property*/  return new Property("property", "code", "A code that identifies a property defined in the code system.", 0, 1, property);
1972          case 3553: /*op*/  return new Property("op", "code", "The kind of operation to perform as a part of the filter criteria.", 0, 1, op);
1973          case 111972721: /*value*/  return new Property("value", "code", "The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.", 0, 1, value);
1974          default: return super.getNamedProperty(_hash, _name, _checkValid);
1975          }
1976
1977        }
1978
1979      @Override
1980      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1981        switch (hash) {
1982        case -993141291: /*property*/ return this.property == null ? new Base[0] : new Base[] {this.property}; // CodeType
1983        case 3553: /*op*/ return this.op == null ? new Base[0] : new Base[] {this.op}; // Enumeration<FilterOperator>
1984        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // CodeType
1985        default: return super.getProperty(hash, name, checkValid);
1986        }
1987
1988      }
1989
1990      @Override
1991      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1992        switch (hash) {
1993        case -993141291: // property
1994          this.property = castToCode(value); // CodeType
1995          return value;
1996        case 3553: // op
1997          value = new FilterOperatorEnumFactory().fromType(castToCode(value));
1998          this.op = (Enumeration) value; // Enumeration<FilterOperator>
1999          return value;
2000        case 111972721: // value
2001          this.value = castToCode(value); // CodeType
2002          return value;
2003        default: return super.setProperty(hash, name, value);
2004        }
2005
2006      }
2007
2008      @Override
2009      public Base setProperty(String name, Base value) throws FHIRException {
2010        if (name.equals("property")) {
2011          this.property = castToCode(value); // CodeType
2012        } else if (name.equals("op")) {
2013          value = new FilterOperatorEnumFactory().fromType(castToCode(value));
2014          this.op = (Enumeration) value; // Enumeration<FilterOperator>
2015        } else if (name.equals("value")) {
2016          this.value = castToCode(value); // CodeType
2017        } else
2018          return super.setProperty(name, value);
2019        return value;
2020      }
2021
2022      @Override
2023      public Base makeProperty(int hash, String name) throws FHIRException {
2024        switch (hash) {
2025        case -993141291:  return getPropertyElement();
2026        case 3553:  return getOpElement();
2027        case 111972721:  return getValueElement();
2028        default: return super.makeProperty(hash, name);
2029        }
2030
2031      }
2032
2033      @Override
2034      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2035        switch (hash) {
2036        case -993141291: /*property*/ return new String[] {"code"};
2037        case 3553: /*op*/ return new String[] {"code"};
2038        case 111972721: /*value*/ return new String[] {"code"};
2039        default: return super.getTypesForProperty(hash, name);
2040        }
2041
2042      }
2043
2044      @Override
2045      public Base addChild(String name) throws FHIRException {
2046        if (name.equals("property")) {
2047          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.property");
2048        }
2049        else if (name.equals("op")) {
2050          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.op");
2051        }
2052        else if (name.equals("value")) {
2053          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.value");
2054        }
2055        else
2056          return super.addChild(name);
2057      }
2058
2059      public ConceptSetFilterComponent copy() {
2060        ConceptSetFilterComponent dst = new ConceptSetFilterComponent();
2061        copyValues(dst);
2062        dst.property = property == null ? null : property.copy();
2063        dst.op = op == null ? null : op.copy();
2064        dst.value = value == null ? null : value.copy();
2065        return dst;
2066      }
2067
2068      @Override
2069      public boolean equalsDeep(Base other_) {
2070        if (!super.equalsDeep(other_))
2071          return false;
2072        if (!(other_ instanceof ConceptSetFilterComponent))
2073          return false;
2074        ConceptSetFilterComponent o = (ConceptSetFilterComponent) other_;
2075        return compareDeep(property, o.property, true) && compareDeep(op, o.op, true) && compareDeep(value, o.value, true)
2076          ;
2077      }
2078
2079      @Override
2080      public boolean equalsShallow(Base other_) {
2081        if (!super.equalsShallow(other_))
2082          return false;
2083        if (!(other_ instanceof ConceptSetFilterComponent))
2084          return false;
2085        ConceptSetFilterComponent o = (ConceptSetFilterComponent) other_;
2086        return compareValues(property, o.property, true) && compareValues(op, o.op, true) && compareValues(value, o.value, true)
2087          ;
2088      }
2089
2090      public boolean isEmpty() {
2091        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(property, op, value);
2092      }
2093
2094  public String fhirType() {
2095    return "ValueSet.compose.include.filter";
2096
2097  }
2098
2099  }
2100
2101    @Block()
2102    public static class ValueSetExpansionComponent extends BackboneElement implements IBaseBackboneElement {
2103        /**
2104         * An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.
2105         */
2106        @Child(name = "identifier", type = {UriType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2107        @Description(shortDefinition="Uniquely identifies this expansion", formalDefinition="An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so." )
2108        protected UriType identifier;
2109
2110        /**
2111         * The time at which the expansion was produced by the expanding system.
2112         */
2113        @Child(name = "timestamp", type = {DateTimeType.class}, order=2, min=1, max=1, modifier=false, summary=false)
2114        @Description(shortDefinition="Time ValueSet expansion happened", formalDefinition="The time at which the expansion was produced by the expanding system." )
2115        protected DateTimeType timestamp;
2116
2117        /**
2118         * The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.
2119         */
2120        @Child(name = "total", type = {IntegerType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2121        @Description(shortDefinition="Total number of codes in the expansion", formalDefinition="The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter." )
2122        protected IntegerType total;
2123
2124        /**
2125         * If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.
2126         */
2127        @Child(name = "offset", type = {IntegerType.class}, order=4, min=0, max=1, modifier=false, summary=false)
2128        @Description(shortDefinition="Offset at which this resource starts", formalDefinition="If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present." )
2129        protected IntegerType offset;
2130
2131        /**
2132         * A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.
2133         */
2134        @Child(name = "parameter", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2135        @Description(shortDefinition="Parameter that controlled the expansion process", formalDefinition="A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion." )
2136        protected List<ValueSetExpansionParameterComponent> parameter;
2137
2138        /**
2139         * The codes that are contained in the value set expansion.
2140         */
2141        @Child(name = "contains", type = {}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2142        @Description(shortDefinition="Codes in the value set", formalDefinition="The codes that are contained in the value set expansion." )
2143        protected List<ValueSetExpansionContainsComponent> contains;
2144
2145        private static final long serialVersionUID = -43471993L;
2146
2147    /**
2148     * Constructor
2149     */
2150      public ValueSetExpansionComponent() {
2151        super();
2152      }
2153
2154    /**
2155     * Constructor
2156     */
2157      public ValueSetExpansionComponent(UriType identifier, DateTimeType timestamp) {
2158        super();
2159        this.identifier = identifier;
2160        this.timestamp = timestamp;
2161      }
2162
2163        /**
2164         * @return {@link #identifier} (An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.). This is the underlying object with id, value and extensions. The accessor "getIdentifier" gives direct access to the value
2165         */
2166        public UriType getIdentifierElement() { 
2167          if (this.identifier == null)
2168            if (Configuration.errorOnAutoCreate())
2169              throw new Error("Attempt to auto-create ValueSetExpansionComponent.identifier");
2170            else if (Configuration.doAutoCreate())
2171              this.identifier = new UriType(); // bb
2172          return this.identifier;
2173        }
2174
2175        public boolean hasIdentifierElement() { 
2176          return this.identifier != null && !this.identifier.isEmpty();
2177        }
2178
2179        public boolean hasIdentifier() { 
2180          return this.identifier != null && !this.identifier.isEmpty();
2181        }
2182
2183        /**
2184         * @param value {@link #identifier} (An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.). This is the underlying object with id, value and extensions. The accessor "getIdentifier" gives direct access to the value
2185         */
2186        public ValueSetExpansionComponent setIdentifierElement(UriType value) { 
2187          this.identifier = value;
2188          return this;
2189        }
2190
2191        /**
2192         * @return An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.
2193         */
2194        public String getIdentifier() { 
2195          return this.identifier == null ? null : this.identifier.getValue();
2196        }
2197
2198        /**
2199         * @param value An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.
2200         */
2201        public ValueSetExpansionComponent setIdentifier(String value) { 
2202            if (this.identifier == null)
2203              this.identifier = new UriType();
2204            this.identifier.setValue(value);
2205          return this;
2206        }
2207
2208        /**
2209         * @return {@link #timestamp} (The time at which the expansion was produced by the expanding system.). This is the underlying object with id, value and extensions. The accessor "getTimestamp" gives direct access to the value
2210         */
2211        public DateTimeType getTimestampElement() { 
2212          if (this.timestamp == null)
2213            if (Configuration.errorOnAutoCreate())
2214              throw new Error("Attempt to auto-create ValueSetExpansionComponent.timestamp");
2215            else if (Configuration.doAutoCreate())
2216              this.timestamp = new DateTimeType(); // bb
2217          return this.timestamp;
2218        }
2219
2220        public boolean hasTimestampElement() { 
2221          return this.timestamp != null && !this.timestamp.isEmpty();
2222        }
2223
2224        public boolean hasTimestamp() { 
2225          return this.timestamp != null && !this.timestamp.isEmpty();
2226        }
2227
2228        /**
2229         * @param value {@link #timestamp} (The time at which the expansion was produced by the expanding system.). This is the underlying object with id, value and extensions. The accessor "getTimestamp" gives direct access to the value
2230         */
2231        public ValueSetExpansionComponent setTimestampElement(DateTimeType value) { 
2232          this.timestamp = value;
2233          return this;
2234        }
2235
2236        /**
2237         * @return The time at which the expansion was produced by the expanding system.
2238         */
2239        public Date getTimestamp() { 
2240          return this.timestamp == null ? null : this.timestamp.getValue();
2241        }
2242
2243        /**
2244         * @param value The time at which the expansion was produced by the expanding system.
2245         */
2246        public ValueSetExpansionComponent setTimestamp(Date value) { 
2247            if (this.timestamp == null)
2248              this.timestamp = new DateTimeType();
2249            this.timestamp.setValue(value);
2250          return this;
2251        }
2252
2253        /**
2254         * @return {@link #total} (The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.). This is the underlying object with id, value and extensions. The accessor "getTotal" gives direct access to the value
2255         */
2256        public IntegerType getTotalElement() { 
2257          if (this.total == null)
2258            if (Configuration.errorOnAutoCreate())
2259              throw new Error("Attempt to auto-create ValueSetExpansionComponent.total");
2260            else if (Configuration.doAutoCreate())
2261              this.total = new IntegerType(); // bb
2262          return this.total;
2263        }
2264
2265        public boolean hasTotalElement() { 
2266          return this.total != null && !this.total.isEmpty();
2267        }
2268
2269        public boolean hasTotal() { 
2270          return this.total != null && !this.total.isEmpty();
2271        }
2272
2273        /**
2274         * @param value {@link #total} (The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.). This is the underlying object with id, value and extensions. The accessor "getTotal" gives direct access to the value
2275         */
2276        public ValueSetExpansionComponent setTotalElement(IntegerType value) { 
2277          this.total = value;
2278          return this;
2279        }
2280
2281        /**
2282         * @return The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.
2283         */
2284        public int getTotal() { 
2285          return this.total == null || this.total.isEmpty() ? 0 : this.total.getValue();
2286        }
2287
2288        /**
2289         * @param value The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.
2290         */
2291        public ValueSetExpansionComponent setTotal(int value) { 
2292            if (this.total == null)
2293              this.total = new IntegerType();
2294            this.total.setValue(value);
2295          return this;
2296        }
2297
2298        /**
2299         * @return {@link #offset} (If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.). This is the underlying object with id, value and extensions. The accessor "getOffset" gives direct access to the value
2300         */
2301        public IntegerType getOffsetElement() { 
2302          if (this.offset == null)
2303            if (Configuration.errorOnAutoCreate())
2304              throw new Error("Attempt to auto-create ValueSetExpansionComponent.offset");
2305            else if (Configuration.doAutoCreate())
2306              this.offset = new IntegerType(); // bb
2307          return this.offset;
2308        }
2309
2310        public boolean hasOffsetElement() { 
2311          return this.offset != null && !this.offset.isEmpty();
2312        }
2313
2314        public boolean hasOffset() { 
2315          return this.offset != null && !this.offset.isEmpty();
2316        }
2317
2318        /**
2319         * @param value {@link #offset} (If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.). This is the underlying object with id, value and extensions. The accessor "getOffset" gives direct access to the value
2320         */
2321        public ValueSetExpansionComponent setOffsetElement(IntegerType value) { 
2322          this.offset = value;
2323          return this;
2324        }
2325
2326        /**
2327         * @return If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.
2328         */
2329        public int getOffset() { 
2330          return this.offset == null || this.offset.isEmpty() ? 0 : this.offset.getValue();
2331        }
2332
2333        /**
2334         * @param value If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.
2335         */
2336        public ValueSetExpansionComponent setOffset(int value) { 
2337            if (this.offset == null)
2338              this.offset = new IntegerType();
2339            this.offset.setValue(value);
2340          return this;
2341        }
2342
2343        /**
2344         * @return {@link #parameter} (A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.)
2345         */
2346        public List<ValueSetExpansionParameterComponent> getParameter() { 
2347          if (this.parameter == null)
2348            this.parameter = new ArrayList<ValueSetExpansionParameterComponent>();
2349          return this.parameter;
2350        }
2351
2352        /**
2353         * @return Returns a reference to <code>this</code> for easy method chaining
2354         */
2355        public ValueSetExpansionComponent setParameter(List<ValueSetExpansionParameterComponent> theParameter) { 
2356          this.parameter = theParameter;
2357          return this;
2358        }
2359
2360        public boolean hasParameter() { 
2361          if (this.parameter == null)
2362            return false;
2363          for (ValueSetExpansionParameterComponent item : this.parameter)
2364            if (!item.isEmpty())
2365              return true;
2366          return false;
2367        }
2368
2369        public ValueSetExpansionParameterComponent addParameter() { //3
2370          ValueSetExpansionParameterComponent t = new ValueSetExpansionParameterComponent();
2371          if (this.parameter == null)
2372            this.parameter = new ArrayList<ValueSetExpansionParameterComponent>();
2373          this.parameter.add(t);
2374          return t;
2375        }
2376
2377        public ValueSetExpansionComponent addParameter(ValueSetExpansionParameterComponent t) { //3
2378          if (t == null)
2379            return this;
2380          if (this.parameter == null)
2381            this.parameter = new ArrayList<ValueSetExpansionParameterComponent>();
2382          this.parameter.add(t);
2383          return this;
2384        }
2385
2386        /**
2387         * @return The first repetition of repeating field {@link #parameter}, creating it if it does not already exist
2388         */
2389        public ValueSetExpansionParameterComponent getParameterFirstRep() { 
2390          if (getParameter().isEmpty()) {
2391            addParameter();
2392          }
2393          return getParameter().get(0);
2394        }
2395
2396        /**
2397         * @return {@link #contains} (The codes that are contained in the value set expansion.)
2398         */
2399        public List<ValueSetExpansionContainsComponent> getContains() { 
2400          if (this.contains == null)
2401            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
2402          return this.contains;
2403        }
2404
2405        /**
2406         * @return Returns a reference to <code>this</code> for easy method chaining
2407         */
2408        public ValueSetExpansionComponent setContains(List<ValueSetExpansionContainsComponent> theContains) { 
2409          this.contains = theContains;
2410          return this;
2411        }
2412
2413        public boolean hasContains() { 
2414          if (this.contains == null)
2415            return false;
2416          for (ValueSetExpansionContainsComponent item : this.contains)
2417            if (!item.isEmpty())
2418              return true;
2419          return false;
2420        }
2421
2422        public ValueSetExpansionContainsComponent addContains() { //3
2423          ValueSetExpansionContainsComponent t = new ValueSetExpansionContainsComponent();
2424          if (this.contains == null)
2425            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
2426          this.contains.add(t);
2427          return t;
2428        }
2429
2430        public ValueSetExpansionComponent addContains(ValueSetExpansionContainsComponent t) { //3
2431          if (t == null)
2432            return this;
2433          if (this.contains == null)
2434            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
2435          this.contains.add(t);
2436          return this;
2437        }
2438
2439        /**
2440         * @return The first repetition of repeating field {@link #contains}, creating it if it does not already exist
2441         */
2442        public ValueSetExpansionContainsComponent getContainsFirstRep() { 
2443          if (getContains().isEmpty()) {
2444            addContains();
2445          }
2446          return getContains().get(0);
2447        }
2448
2449        protected void listChildren(List<Property> children) {
2450          super.listChildren(children);
2451          children.add(new Property("identifier", "uri", "An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.", 0, 1, identifier));
2452          children.add(new Property("timestamp", "dateTime", "The time at which the expansion was produced by the expanding system.", 0, 1, timestamp));
2453          children.add(new Property("total", "integer", "The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.", 0, 1, total));
2454          children.add(new Property("offset", "integer", "If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.", 0, 1, offset));
2455          children.add(new Property("parameter", "", "A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.", 0, java.lang.Integer.MAX_VALUE, parameter));
2456          children.add(new Property("contains", "", "The codes that are contained in the value set expansion.", 0, java.lang.Integer.MAX_VALUE, contains));
2457        }
2458
2459        @Override
2460        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2461          switch (_hash) {
2462          case -1618432855: /*identifier*/  return new Property("identifier", "uri", "An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.", 0, 1, identifier);
2463          case 55126294: /*timestamp*/  return new Property("timestamp", "dateTime", "The time at which the expansion was produced by the expanding system.", 0, 1, timestamp);
2464          case 110549828: /*total*/  return new Property("total", "integer", "The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.", 0, 1, total);
2465          case -1019779949: /*offset*/  return new Property("offset", "integer", "If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.", 0, 1, offset);
2466          case 1954460585: /*parameter*/  return new Property("parameter", "", "A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.", 0, java.lang.Integer.MAX_VALUE, parameter);
2467          case -567445985: /*contains*/  return new Property("contains", "", "The codes that are contained in the value set expansion.", 0, java.lang.Integer.MAX_VALUE, contains);
2468          default: return super.getNamedProperty(_hash, _name, _checkValid);
2469          }
2470
2471        }
2472
2473      @Override
2474      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2475        switch (hash) {
2476        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : new Base[] {this.identifier}; // UriType
2477        case 55126294: /*timestamp*/ return this.timestamp == null ? new Base[0] : new Base[] {this.timestamp}; // DateTimeType
2478        case 110549828: /*total*/ return this.total == null ? new Base[0] : new Base[] {this.total}; // IntegerType
2479        case -1019779949: /*offset*/ return this.offset == null ? new Base[0] : new Base[] {this.offset}; // IntegerType
2480        case 1954460585: /*parameter*/ return this.parameter == null ? new Base[0] : this.parameter.toArray(new Base[this.parameter.size()]); // ValueSetExpansionParameterComponent
2481        case -567445985: /*contains*/ return this.contains == null ? new Base[0] : this.contains.toArray(new Base[this.contains.size()]); // ValueSetExpansionContainsComponent
2482        default: return super.getProperty(hash, name, checkValid);
2483        }
2484
2485      }
2486
2487      @Override
2488      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2489        switch (hash) {
2490        case -1618432855: // identifier
2491          this.identifier = castToUri(value); // UriType
2492          return value;
2493        case 55126294: // timestamp
2494          this.timestamp = castToDateTime(value); // DateTimeType
2495          return value;
2496        case 110549828: // total
2497          this.total = castToInteger(value); // IntegerType
2498          return value;
2499        case -1019779949: // offset
2500          this.offset = castToInteger(value); // IntegerType
2501          return value;
2502        case 1954460585: // parameter
2503          this.getParameter().add((ValueSetExpansionParameterComponent) value); // ValueSetExpansionParameterComponent
2504          return value;
2505        case -567445985: // contains
2506          this.getContains().add((ValueSetExpansionContainsComponent) value); // ValueSetExpansionContainsComponent
2507          return value;
2508        default: return super.setProperty(hash, name, value);
2509        }
2510
2511      }
2512
2513      @Override
2514      public Base setProperty(String name, Base value) throws FHIRException {
2515        if (name.equals("identifier")) {
2516          this.identifier = castToUri(value); // UriType
2517        } else if (name.equals("timestamp")) {
2518          this.timestamp = castToDateTime(value); // DateTimeType
2519        } else if (name.equals("total")) {
2520          this.total = castToInteger(value); // IntegerType
2521        } else if (name.equals("offset")) {
2522          this.offset = castToInteger(value); // IntegerType
2523        } else if (name.equals("parameter")) {
2524          this.getParameter().add((ValueSetExpansionParameterComponent) value);
2525        } else if (name.equals("contains")) {
2526          this.getContains().add((ValueSetExpansionContainsComponent) value);
2527        } else
2528          return super.setProperty(name, value);
2529        return value;
2530      }
2531
2532      @Override
2533      public Base makeProperty(int hash, String name) throws FHIRException {
2534        switch (hash) {
2535        case -1618432855:  return getIdentifierElement();
2536        case 55126294:  return getTimestampElement();
2537        case 110549828:  return getTotalElement();
2538        case -1019779949:  return getOffsetElement();
2539        case 1954460585:  return addParameter(); 
2540        case -567445985:  return addContains(); 
2541        default: return super.makeProperty(hash, name);
2542        }
2543
2544      }
2545
2546      @Override
2547      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2548        switch (hash) {
2549        case -1618432855: /*identifier*/ return new String[] {"uri"};
2550        case 55126294: /*timestamp*/ return new String[] {"dateTime"};
2551        case 110549828: /*total*/ return new String[] {"integer"};
2552        case -1019779949: /*offset*/ return new String[] {"integer"};
2553        case 1954460585: /*parameter*/ return new String[] {};
2554        case -567445985: /*contains*/ return new String[] {};
2555        default: return super.getTypesForProperty(hash, name);
2556        }
2557
2558      }
2559
2560      @Override
2561      public Base addChild(String name) throws FHIRException {
2562        if (name.equals("identifier")) {
2563          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.identifier");
2564        }
2565        else if (name.equals("timestamp")) {
2566          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.timestamp");
2567        }
2568        else if (name.equals("total")) {
2569          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.total");
2570        }
2571        else if (name.equals("offset")) {
2572          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.offset");
2573        }
2574        else if (name.equals("parameter")) {
2575          return addParameter();
2576        }
2577        else if (name.equals("contains")) {
2578          return addContains();
2579        }
2580        else
2581          return super.addChild(name);
2582      }
2583
2584      public ValueSetExpansionComponent copy() {
2585        ValueSetExpansionComponent dst = new ValueSetExpansionComponent();
2586        copyValues(dst);
2587        dst.identifier = identifier == null ? null : identifier.copy();
2588        dst.timestamp = timestamp == null ? null : timestamp.copy();
2589        dst.total = total == null ? null : total.copy();
2590        dst.offset = offset == null ? null : offset.copy();
2591        if (parameter != null) {
2592          dst.parameter = new ArrayList<ValueSetExpansionParameterComponent>();
2593          for (ValueSetExpansionParameterComponent i : parameter)
2594            dst.parameter.add(i.copy());
2595        };
2596        if (contains != null) {
2597          dst.contains = new ArrayList<ValueSetExpansionContainsComponent>();
2598          for (ValueSetExpansionContainsComponent i : contains)
2599            dst.contains.add(i.copy());
2600        };
2601        return dst;
2602      }
2603
2604      @Override
2605      public boolean equalsDeep(Base other_) {
2606        if (!super.equalsDeep(other_))
2607          return false;
2608        if (!(other_ instanceof ValueSetExpansionComponent))
2609          return false;
2610        ValueSetExpansionComponent o = (ValueSetExpansionComponent) other_;
2611        return compareDeep(identifier, o.identifier, true) && compareDeep(timestamp, o.timestamp, true)
2612           && compareDeep(total, o.total, true) && compareDeep(offset, o.offset, true) && compareDeep(parameter, o.parameter, true)
2613           && compareDeep(contains, o.contains, true);
2614      }
2615
2616      @Override
2617      public boolean equalsShallow(Base other_) {
2618        if (!super.equalsShallow(other_))
2619          return false;
2620        if (!(other_ instanceof ValueSetExpansionComponent))
2621          return false;
2622        ValueSetExpansionComponent o = (ValueSetExpansionComponent) other_;
2623        return compareValues(identifier, o.identifier, true) && compareValues(timestamp, o.timestamp, true)
2624           && compareValues(total, o.total, true) && compareValues(offset, o.offset, true);
2625      }
2626
2627      public boolean isEmpty() {
2628        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, timestamp, total
2629          , offset, parameter, contains);
2630      }
2631
2632  public String fhirType() {
2633    return "ValueSet.expansion";
2634
2635  }
2636
2637  }
2638
2639    @Block()
2640    public static class ValueSetExpansionParameterComponent extends BackboneElement implements IBaseBackboneElement {
2641        /**
2642         * The name of the parameter.
2643         */
2644        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2645        @Description(shortDefinition="Name as assigned by the server", formalDefinition="The name of the parameter." )
2646        protected StringType name;
2647
2648        /**
2649         * The value of the parameter.
2650         */
2651        @Child(name = "value", type = {StringType.class, BooleanType.class, IntegerType.class, DecimalType.class, UriType.class, CodeType.class}, order=2, min=0, max=1, modifier=false, summary=false)
2652        @Description(shortDefinition="Value of the named parameter", formalDefinition="The value of the parameter." )
2653        protected Type value;
2654
2655        private static final long serialVersionUID = 1172641169L;
2656
2657    /**
2658     * Constructor
2659     */
2660      public ValueSetExpansionParameterComponent() {
2661        super();
2662      }
2663
2664    /**
2665     * Constructor
2666     */
2667      public ValueSetExpansionParameterComponent(StringType name) {
2668        super();
2669        this.name = name;
2670      }
2671
2672        /**
2673         * @return {@link #name} (The name of the parameter.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2674         */
2675        public StringType getNameElement() { 
2676          if (this.name == null)
2677            if (Configuration.errorOnAutoCreate())
2678              throw new Error("Attempt to auto-create ValueSetExpansionParameterComponent.name");
2679            else if (Configuration.doAutoCreate())
2680              this.name = new StringType(); // bb
2681          return this.name;
2682        }
2683
2684        public boolean hasNameElement() { 
2685          return this.name != null && !this.name.isEmpty();
2686        }
2687
2688        public boolean hasName() { 
2689          return this.name != null && !this.name.isEmpty();
2690        }
2691
2692        /**
2693         * @param value {@link #name} (The name of the parameter.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2694         */
2695        public ValueSetExpansionParameterComponent setNameElement(StringType value) { 
2696          this.name = value;
2697          return this;
2698        }
2699
2700        /**
2701         * @return The name of the parameter.
2702         */
2703        public String getName() { 
2704          return this.name == null ? null : this.name.getValue();
2705        }
2706
2707        /**
2708         * @param value The name of the parameter.
2709         */
2710        public ValueSetExpansionParameterComponent setName(String value) { 
2711            if (this.name == null)
2712              this.name = new StringType();
2713            this.name.setValue(value);
2714          return this;
2715        }
2716
2717        /**
2718         * @return {@link #value} (The value of the parameter.)
2719         */
2720        public Type getValue() { 
2721          return this.value;
2722        }
2723
2724        /**
2725         * @return {@link #value} (The value of the parameter.)
2726         */
2727        public StringType getValueStringType() throws FHIRException { 
2728          if (this.value == null)
2729            return null;
2730          if (!(this.value instanceof StringType))
2731            throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered");
2732          return (StringType) this.value;
2733        }
2734
2735        public boolean hasValueStringType() { 
2736          return this != null && this.value instanceof StringType;
2737        }
2738
2739        /**
2740         * @return {@link #value} (The value of the parameter.)
2741         */
2742        public BooleanType getValueBooleanType() throws FHIRException { 
2743          if (this.value == null)
2744            return null;
2745          if (!(this.value instanceof BooleanType))
2746            throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered");
2747          return (BooleanType) this.value;
2748        }
2749
2750        public boolean hasValueBooleanType() { 
2751          return this != null && this.value instanceof BooleanType;
2752        }
2753
2754        /**
2755         * @return {@link #value} (The value of the parameter.)
2756         */
2757        public IntegerType getValueIntegerType() throws FHIRException { 
2758          if (this.value == null)
2759            return null;
2760          if (!(this.value instanceof IntegerType))
2761            throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered");
2762          return (IntegerType) this.value;
2763        }
2764
2765        public boolean hasValueIntegerType() { 
2766          return this != null && this.value instanceof IntegerType;
2767        }
2768
2769        /**
2770         * @return {@link #value} (The value of the parameter.)
2771         */
2772        public DecimalType getValueDecimalType() throws FHIRException { 
2773          if (this.value == null)
2774            return null;
2775          if (!(this.value instanceof DecimalType))
2776            throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.value.getClass().getName()+" was encountered");
2777          return (DecimalType) this.value;
2778        }
2779
2780        public boolean hasValueDecimalType() { 
2781          return this != null && this.value instanceof DecimalType;
2782        }
2783
2784        /**
2785         * @return {@link #value} (The value of the parameter.)
2786         */
2787        public UriType getValueUriType() throws FHIRException { 
2788          if (this.value == null)
2789            return null;
2790          if (!(this.value instanceof UriType))
2791            throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.value.getClass().getName()+" was encountered");
2792          return (UriType) this.value;
2793        }
2794
2795        public boolean hasValueUriType() { 
2796          return this != null && this.value instanceof UriType;
2797        }
2798
2799        /**
2800         * @return {@link #value} (The value of the parameter.)
2801         */
2802        public CodeType getValueCodeType() throws FHIRException { 
2803          if (this.value == null)
2804            return null;
2805          if (!(this.value instanceof CodeType))
2806            throw new FHIRException("Type mismatch: the type CodeType was expected, but "+this.value.getClass().getName()+" was encountered");
2807          return (CodeType) this.value;
2808        }
2809
2810        public boolean hasValueCodeType() { 
2811          return this != null && this.value instanceof CodeType;
2812        }
2813
2814        public boolean hasValue() { 
2815          return this.value != null && !this.value.isEmpty();
2816        }
2817
2818        /**
2819         * @param value {@link #value} (The value of the parameter.)
2820         */
2821        public ValueSetExpansionParameterComponent setValue(Type value) throws FHIRFormatError { 
2822          if (value != null && !(value instanceof StringType || value instanceof BooleanType || value instanceof IntegerType || value instanceof DecimalType || value instanceof UriType || value instanceof CodeType))
2823            throw new FHIRFormatError("Not the right type for ValueSet.expansion.parameter.value[x]: "+value.fhirType());
2824          this.value = value;
2825          return this;
2826        }
2827
2828        protected void listChildren(List<Property> children) {
2829          super.listChildren(children);
2830          children.add(new Property("name", "string", "The name of the parameter.", 0, 1, name));
2831          children.add(new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value));
2832        }
2833
2834        @Override
2835        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2836          switch (_hash) {
2837          case 3373707: /*name*/  return new Property("name", "string", "The name of the parameter.", 0, 1, name);
2838          case -1410166417: /*value[x]*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2839          case 111972721: /*value*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2840          case -1424603934: /*valueString*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2841          case 733421943: /*valueBoolean*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2842          case -1668204915: /*valueInteger*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2843          case -2083993440: /*valueDecimal*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2844          case -1410172357: /*valueUri*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2845          case -766209282: /*valueCode*/  return new Property("value[x]", "string|boolean|integer|decimal|uri|code", "The value of the parameter.", 0, 1, value);
2846          default: return super.getNamedProperty(_hash, _name, _checkValid);
2847          }
2848
2849        }
2850
2851      @Override
2852      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2853        switch (hash) {
2854        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
2855        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // Type
2856        default: return super.getProperty(hash, name, checkValid);
2857        }
2858
2859      }
2860
2861      @Override
2862      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2863        switch (hash) {
2864        case 3373707: // name
2865          this.name = castToString(value); // StringType
2866          return value;
2867        case 111972721: // value
2868          this.value = castToType(value); // Type
2869          return value;
2870        default: return super.setProperty(hash, name, value);
2871        }
2872
2873      }
2874
2875      @Override
2876      public Base setProperty(String name, Base value) throws FHIRException {
2877        if (name.equals("name")) {
2878          this.name = castToString(value); // StringType
2879        } else if (name.equals("value[x]")) {
2880          this.value = castToType(value); // Type
2881        } else
2882          return super.setProperty(name, value);
2883        return value;
2884      }
2885
2886      @Override
2887      public Base makeProperty(int hash, String name) throws FHIRException {
2888        switch (hash) {
2889        case 3373707:  return getNameElement();
2890        case -1410166417:  return getValue(); 
2891        case 111972721:  return getValue(); 
2892        default: return super.makeProperty(hash, name);
2893        }
2894
2895      }
2896
2897      @Override
2898      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2899        switch (hash) {
2900        case 3373707: /*name*/ return new String[] {"string"};
2901        case 111972721: /*value*/ return new String[] {"string", "boolean", "integer", "decimal", "uri", "code"};
2902        default: return super.getTypesForProperty(hash, name);
2903        }
2904
2905      }
2906
2907      @Override
2908      public Base addChild(String name) throws FHIRException {
2909        if (name.equals("name")) {
2910          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.name");
2911        }
2912        else if (name.equals("valueString")) {
2913          this.value = new StringType();
2914          return this.value;
2915        }
2916        else if (name.equals("valueBoolean")) {
2917          this.value = new BooleanType();
2918          return this.value;
2919        }
2920        else if (name.equals("valueInteger")) {
2921          this.value = new IntegerType();
2922          return this.value;
2923        }
2924        else if (name.equals("valueDecimal")) {
2925          this.value = new DecimalType();
2926          return this.value;
2927        }
2928        else if (name.equals("valueUri")) {
2929          this.value = new UriType();
2930          return this.value;
2931        }
2932        else if (name.equals("valueCode")) {
2933          this.value = new CodeType();
2934          return this.value;
2935        }
2936        else
2937          return super.addChild(name);
2938      }
2939
2940      public ValueSetExpansionParameterComponent copy() {
2941        ValueSetExpansionParameterComponent dst = new ValueSetExpansionParameterComponent();
2942        copyValues(dst);
2943        dst.name = name == null ? null : name.copy();
2944        dst.value = value == null ? null : value.copy();
2945        return dst;
2946      }
2947
2948      @Override
2949      public boolean equalsDeep(Base other_) {
2950        if (!super.equalsDeep(other_))
2951          return false;
2952        if (!(other_ instanceof ValueSetExpansionParameterComponent))
2953          return false;
2954        ValueSetExpansionParameterComponent o = (ValueSetExpansionParameterComponent) other_;
2955        return compareDeep(name, o.name, true) && compareDeep(value, o.value, true);
2956      }
2957
2958      @Override
2959      public boolean equalsShallow(Base other_) {
2960        if (!super.equalsShallow(other_))
2961          return false;
2962        if (!(other_ instanceof ValueSetExpansionParameterComponent))
2963          return false;
2964        ValueSetExpansionParameterComponent o = (ValueSetExpansionParameterComponent) other_;
2965        return compareValues(name, o.name, true);
2966      }
2967
2968      public boolean isEmpty() {
2969        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, value);
2970      }
2971
2972  public String fhirType() {
2973    return "ValueSet.expansion.parameter";
2974
2975  }
2976
2977  }
2978
2979    @Block()
2980    public static class ValueSetExpansionContainsComponent extends BackboneElement implements IBaseBackboneElement {
2981        /**
2982         * An absolute URI which is the code system in which the code for this item in the expansion is defined.
2983         */
2984        @Child(name = "system", type = {UriType.class}, order=1, min=0, max=1, modifier=false, summary=false)
2985        @Description(shortDefinition="System value for the code", formalDefinition="An absolute URI which is the code system in which the code for this item in the expansion is defined." )
2986        protected UriType system;
2987
2988        /**
2989         * If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.
2990         */
2991        @Child(name = "abstract", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=false)
2992        @Description(shortDefinition="If user cannot select this entry", formalDefinition="If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value." )
2993        protected BooleanType abstract_;
2994
2995        /**
2996         * If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.
2997         */
2998        @Child(name = "inactive", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2999        @Description(shortDefinition="If concept is inactive in the code system", formalDefinition="If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data." )
3000        protected BooleanType inactive;
3001
3002        /**
3003         * The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.
3004         */
3005        @Child(name = "version", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
3006        @Description(shortDefinition="Version in which this code/display is defined", formalDefinition="The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence." )
3007        protected StringType version;
3008
3009        /**
3010         * The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.
3011         */
3012        @Child(name = "code", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=false)
3013        @Description(shortDefinition="Code - if blank, this is not a selectable code", formalDefinition="The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set." )
3014        protected CodeType code;
3015
3016        /**
3017         * The recommended display for this item in the expansion.
3018         */
3019        @Child(name = "display", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
3020        @Description(shortDefinition="User display for the concept", formalDefinition="The recommended display for this item in the expansion." )
3021        protected StringType display;
3022
3023        /**
3024         * Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.
3025         */
3026        @Child(name = "designation", type = {ConceptReferenceDesignationComponent.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3027        @Description(shortDefinition="Additional representations for this item", formalDefinition="Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation." )
3028        protected List<ConceptReferenceDesignationComponent> designation;
3029
3030        /**
3031         * Other codes and entries contained under this entry in the hierarchy.
3032         */
3033        @Child(name = "contains", type = {ValueSetExpansionContainsComponent.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3034        @Description(shortDefinition="Codes contained under this entry", formalDefinition="Other codes and entries contained under this entry in the hierarchy." )
3035        protected List<ValueSetExpansionContainsComponent> contains;
3036
3037        private static final long serialVersionUID = 719458860L;
3038
3039    /**
3040     * Constructor
3041     */
3042      public ValueSetExpansionContainsComponent() {
3043        super();
3044      }
3045
3046        /**
3047         * @return {@link #system} (An absolute URI which is the code system in which the code for this item in the expansion is defined.). This is the underlying object with id, value and extensions. The accessor "getSystem" gives direct access to the value
3048         */
3049        public UriType getSystemElement() { 
3050          if (this.system == null)
3051            if (Configuration.errorOnAutoCreate())
3052              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.system");
3053            else if (Configuration.doAutoCreate())
3054              this.system = new UriType(); // bb
3055          return this.system;
3056        }
3057
3058        public boolean hasSystemElement() { 
3059          return this.system != null && !this.system.isEmpty();
3060        }
3061
3062        public boolean hasSystem() { 
3063          return this.system != null && !this.system.isEmpty();
3064        }
3065
3066        /**
3067         * @param value {@link #system} (An absolute URI which is the code system in which the code for this item in the expansion is defined.). This is the underlying object with id, value and extensions. The accessor "getSystem" gives direct access to the value
3068         */
3069        public ValueSetExpansionContainsComponent setSystemElement(UriType value) { 
3070          this.system = value;
3071          return this;
3072        }
3073
3074        /**
3075         * @return An absolute URI which is the code system in which the code for this item in the expansion is defined.
3076         */
3077        public String getSystem() { 
3078          return this.system == null ? null : this.system.getValue();
3079        }
3080
3081        /**
3082         * @param value An absolute URI which is the code system in which the code for this item in the expansion is defined.
3083         */
3084        public ValueSetExpansionContainsComponent setSystem(String value) { 
3085          if (Utilities.noString(value))
3086            this.system = null;
3087          else {
3088            if (this.system == null)
3089              this.system = new UriType();
3090            this.system.setValue(value);
3091          }
3092          return this;
3093        }
3094
3095        /**
3096         * @return {@link #abstract_} (If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.). This is the underlying object with id, value and extensions. The accessor "getAbstract" gives direct access to the value
3097         */
3098        public BooleanType getAbstractElement() { 
3099          if (this.abstract_ == null)
3100            if (Configuration.errorOnAutoCreate())
3101              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.abstract_");
3102            else if (Configuration.doAutoCreate())
3103              this.abstract_ = new BooleanType(); // bb
3104          return this.abstract_;
3105        }
3106
3107        public boolean hasAbstractElement() { 
3108          return this.abstract_ != null && !this.abstract_.isEmpty();
3109        }
3110
3111        public boolean hasAbstract() { 
3112          return this.abstract_ != null && !this.abstract_.isEmpty();
3113        }
3114
3115        /**
3116         * @param value {@link #abstract_} (If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.). This is the underlying object with id, value and extensions. The accessor "getAbstract" gives direct access to the value
3117         */
3118        public ValueSetExpansionContainsComponent setAbstractElement(BooleanType value) { 
3119          this.abstract_ = value;
3120          return this;
3121        }
3122
3123        /**
3124         * @return If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.
3125         */
3126        public boolean getAbstract() { 
3127          return this.abstract_ == null || this.abstract_.isEmpty() ? false : this.abstract_.getValue();
3128        }
3129
3130        /**
3131         * @param value If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.
3132         */
3133        public ValueSetExpansionContainsComponent setAbstract(boolean value) { 
3134            if (this.abstract_ == null)
3135              this.abstract_ = new BooleanType();
3136            this.abstract_.setValue(value);
3137          return this;
3138        }
3139
3140        /**
3141         * @return {@link #inactive} (If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value
3142         */
3143        public BooleanType getInactiveElement() { 
3144          if (this.inactive == null)
3145            if (Configuration.errorOnAutoCreate())
3146              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.inactive");
3147            else if (Configuration.doAutoCreate())
3148              this.inactive = new BooleanType(); // bb
3149          return this.inactive;
3150        }
3151
3152        public boolean hasInactiveElement() { 
3153          return this.inactive != null && !this.inactive.isEmpty();
3154        }
3155
3156        public boolean hasInactive() { 
3157          return this.inactive != null && !this.inactive.isEmpty();
3158        }
3159
3160        /**
3161         * @param value {@link #inactive} (If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.). This is the underlying object with id, value and extensions. The accessor "getInactive" gives direct access to the value
3162         */
3163        public ValueSetExpansionContainsComponent setInactiveElement(BooleanType value) { 
3164          this.inactive = value;
3165          return this;
3166        }
3167
3168        /**
3169         * @return If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.
3170         */
3171        public boolean getInactive() { 
3172          return this.inactive == null || this.inactive.isEmpty() ? false : this.inactive.getValue();
3173        }
3174
3175        /**
3176         * @param value If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.
3177         */
3178        public ValueSetExpansionContainsComponent setInactive(boolean value) { 
3179            if (this.inactive == null)
3180              this.inactive = new BooleanType();
3181            this.inactive.setValue(value);
3182          return this;
3183        }
3184
3185        /**
3186         * @return {@link #version} (The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
3187         */
3188        public StringType getVersionElement() { 
3189          if (this.version == null)
3190            if (Configuration.errorOnAutoCreate())
3191              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.version");
3192            else if (Configuration.doAutoCreate())
3193              this.version = new StringType(); // bb
3194          return this.version;
3195        }
3196
3197        public boolean hasVersionElement() { 
3198          return this.version != null && !this.version.isEmpty();
3199        }
3200
3201        public boolean hasVersion() { 
3202          return this.version != null && !this.version.isEmpty();
3203        }
3204
3205        /**
3206         * @param value {@link #version} (The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
3207         */
3208        public ValueSetExpansionContainsComponent setVersionElement(StringType value) { 
3209          this.version = value;
3210          return this;
3211        }
3212
3213        /**
3214         * @return The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.
3215         */
3216        public String getVersion() { 
3217          return this.version == null ? null : this.version.getValue();
3218        }
3219
3220        /**
3221         * @param value The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.
3222         */
3223        public ValueSetExpansionContainsComponent setVersion(String value) { 
3224          if (Utilities.noString(value))
3225            this.version = null;
3226          else {
3227            if (this.version == null)
3228              this.version = new StringType();
3229            this.version.setValue(value);
3230          }
3231          return this;
3232        }
3233
3234        /**
3235         * @return {@link #code} (The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
3236         */
3237        public CodeType getCodeElement() { 
3238          if (this.code == null)
3239            if (Configuration.errorOnAutoCreate())
3240              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.code");
3241            else if (Configuration.doAutoCreate())
3242              this.code = new CodeType(); // bb
3243          return this.code;
3244        }
3245
3246        public boolean hasCodeElement() { 
3247          return this.code != null && !this.code.isEmpty();
3248        }
3249
3250        public boolean hasCode() { 
3251          return this.code != null && !this.code.isEmpty();
3252        }
3253
3254        /**
3255         * @param value {@link #code} (The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
3256         */
3257        public ValueSetExpansionContainsComponent setCodeElement(CodeType value) { 
3258          this.code = value;
3259          return this;
3260        }
3261
3262        /**
3263         * @return The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.
3264         */
3265        public String getCode() { 
3266          return this.code == null ? null : this.code.getValue();
3267        }
3268
3269        /**
3270         * @param value The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.
3271         */
3272        public ValueSetExpansionContainsComponent setCode(String value) { 
3273          if (Utilities.noString(value))
3274            this.code = null;
3275          else {
3276            if (this.code == null)
3277              this.code = new CodeType();
3278            this.code.setValue(value);
3279          }
3280          return this;
3281        }
3282
3283        /**
3284         * @return {@link #display} (The recommended display for this item in the expansion.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
3285         */
3286        public StringType getDisplayElement() { 
3287          if (this.display == null)
3288            if (Configuration.errorOnAutoCreate())
3289              throw new Error("Attempt to auto-create ValueSetExpansionContainsComponent.display");
3290            else if (Configuration.doAutoCreate())
3291              this.display = new StringType(); // bb
3292          return this.display;
3293        }
3294
3295        public boolean hasDisplayElement() { 
3296          return this.display != null && !this.display.isEmpty();
3297        }
3298
3299        public boolean hasDisplay() { 
3300          return this.display != null && !this.display.isEmpty();
3301        }
3302
3303        /**
3304         * @param value {@link #display} (The recommended display for this item in the expansion.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
3305         */
3306        public ValueSetExpansionContainsComponent setDisplayElement(StringType value) { 
3307          this.display = value;
3308          return this;
3309        }
3310
3311        /**
3312         * @return The recommended display for this item in the expansion.
3313         */
3314        public String getDisplay() { 
3315          return this.display == null ? null : this.display.getValue();
3316        }
3317
3318        /**
3319         * @param value The recommended display for this item in the expansion.
3320         */
3321        public ValueSetExpansionContainsComponent setDisplay(String value) { 
3322          if (Utilities.noString(value))
3323            this.display = null;
3324          else {
3325            if (this.display == null)
3326              this.display = new StringType();
3327            this.display.setValue(value);
3328          }
3329          return this;
3330        }
3331
3332        /**
3333         * @return {@link #designation} (Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.)
3334         */
3335        public List<ConceptReferenceDesignationComponent> getDesignation() { 
3336          if (this.designation == null)
3337            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
3338          return this.designation;
3339        }
3340
3341        /**
3342         * @return Returns a reference to <code>this</code> for easy method chaining
3343         */
3344        public ValueSetExpansionContainsComponent setDesignation(List<ConceptReferenceDesignationComponent> theDesignation) { 
3345          this.designation = theDesignation;
3346          return this;
3347        }
3348
3349        public boolean hasDesignation() { 
3350          if (this.designation == null)
3351            return false;
3352          for (ConceptReferenceDesignationComponent item : this.designation)
3353            if (!item.isEmpty())
3354              return true;
3355          return false;
3356        }
3357
3358        public ConceptReferenceDesignationComponent addDesignation() { //3
3359          ConceptReferenceDesignationComponent t = new ConceptReferenceDesignationComponent();
3360          if (this.designation == null)
3361            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
3362          this.designation.add(t);
3363          return t;
3364        }
3365
3366        public ValueSetExpansionContainsComponent addDesignation(ConceptReferenceDesignationComponent t) { //3
3367          if (t == null)
3368            return this;
3369          if (this.designation == null)
3370            this.designation = new ArrayList<ConceptReferenceDesignationComponent>();
3371          this.designation.add(t);
3372          return this;
3373        }
3374
3375        /**
3376         * @return The first repetition of repeating field {@link #designation}, creating it if it does not already exist
3377         */
3378        public ConceptReferenceDesignationComponent getDesignationFirstRep() { 
3379          if (getDesignation().isEmpty()) {
3380            addDesignation();
3381          }
3382          return getDesignation().get(0);
3383        }
3384
3385        /**
3386         * @return {@link #contains} (Other codes and entries contained under this entry in the hierarchy.)
3387         */
3388        public List<ValueSetExpansionContainsComponent> getContains() { 
3389          if (this.contains == null)
3390            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
3391          return this.contains;
3392        }
3393
3394        /**
3395         * @return Returns a reference to <code>this</code> for easy method chaining
3396         */
3397        public ValueSetExpansionContainsComponent setContains(List<ValueSetExpansionContainsComponent> theContains) { 
3398          this.contains = theContains;
3399          return this;
3400        }
3401
3402        public boolean hasContains() { 
3403          if (this.contains == null)
3404            return false;
3405          for (ValueSetExpansionContainsComponent item : this.contains)
3406            if (!item.isEmpty())
3407              return true;
3408          return false;
3409        }
3410
3411        public ValueSetExpansionContainsComponent addContains() { //3
3412          ValueSetExpansionContainsComponent t = new ValueSetExpansionContainsComponent();
3413          if (this.contains == null)
3414            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
3415          this.contains.add(t);
3416          return t;
3417        }
3418
3419        public ValueSetExpansionContainsComponent addContains(ValueSetExpansionContainsComponent t) { //3
3420          if (t == null)
3421            return this;
3422          if (this.contains == null)
3423            this.contains = new ArrayList<ValueSetExpansionContainsComponent>();
3424          this.contains.add(t);
3425          return this;
3426        }
3427
3428        /**
3429         * @return The first repetition of repeating field {@link #contains}, creating it if it does not already exist
3430         */
3431        public ValueSetExpansionContainsComponent getContainsFirstRep() { 
3432          if (getContains().isEmpty()) {
3433            addContains();
3434          }
3435          return getContains().get(0);
3436        }
3437
3438        protected void listChildren(List<Property> children) {
3439          super.listChildren(children);
3440          children.add(new Property("system", "uri", "An absolute URI which is the code system in which the code for this item in the expansion is defined.", 0, 1, system));
3441          children.add(new Property("abstract", "boolean", "If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.", 0, 1, abstract_));
3442          children.add(new Property("inactive", "boolean", "If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.", 0, 1, inactive));
3443          children.add(new Property("version", "string", "The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.", 0, 1, version));
3444          children.add(new Property("code", "code", "The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.", 0, 1, code));
3445          children.add(new Property("display", "string", "The recommended display for this item in the expansion.", 0, 1, display));
3446          children.add(new Property("designation", "@ValueSet.compose.include.concept.designation", "Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.", 0, java.lang.Integer.MAX_VALUE, designation));
3447          children.add(new Property("contains", "@ValueSet.expansion.contains", "Other codes and entries contained under this entry in the hierarchy.", 0, java.lang.Integer.MAX_VALUE, contains));
3448        }
3449
3450        @Override
3451        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3452          switch (_hash) {
3453          case -887328209: /*system*/  return new Property("system", "uri", "An absolute URI which is the code system in which the code for this item in the expansion is defined.", 0, 1, system);
3454          case 1732898850: /*abstract*/  return new Property("abstract", "boolean", "If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.", 0, 1, abstract_);
3455          case 24665195: /*inactive*/  return new Property("inactive", "boolean", "If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.", 0, 1, inactive);
3456          case 351608024: /*version*/  return new Property("version", "string", "The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.", 0, 1, version);
3457          case 3059181: /*code*/  return new Property("code", "code", "The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.", 0, 1, code);
3458          case 1671764162: /*display*/  return new Property("display", "string", "The recommended display for this item in the expansion.", 0, 1, display);
3459          case -900931593: /*designation*/  return new Property("designation", "@ValueSet.compose.include.concept.designation", "Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.", 0, java.lang.Integer.MAX_VALUE, designation);
3460          case -567445985: /*contains*/  return new Property("contains", "@ValueSet.expansion.contains", "Other codes and entries contained under this entry in the hierarchy.", 0, java.lang.Integer.MAX_VALUE, contains);
3461          default: return super.getNamedProperty(_hash, _name, _checkValid);
3462          }
3463
3464        }
3465
3466      @Override
3467      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3468        switch (hash) {
3469        case -887328209: /*system*/ return this.system == null ? new Base[0] : new Base[] {this.system}; // UriType
3470        case 1732898850: /*abstract*/ return this.abstract_ == null ? new Base[0] : new Base[] {this.abstract_}; // BooleanType
3471        case 24665195: /*inactive*/ return this.inactive == null ? new Base[0] : new Base[] {this.inactive}; // BooleanType
3472        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
3473        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType
3474        case 1671764162: /*display*/ return this.display == null ? new Base[0] : new Base[] {this.display}; // StringType
3475        case -900931593: /*designation*/ return this.designation == null ? new Base[0] : this.designation.toArray(new Base[this.designation.size()]); // ConceptReferenceDesignationComponent
3476        case -567445985: /*contains*/ return this.contains == null ? new Base[0] : this.contains.toArray(new Base[this.contains.size()]); // ValueSetExpansionContainsComponent
3477        default: return super.getProperty(hash, name, checkValid);
3478        }
3479
3480      }
3481
3482      @Override
3483      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3484        switch (hash) {
3485        case -887328209: // system
3486          this.system = castToUri(value); // UriType
3487          return value;
3488        case 1732898850: // abstract
3489          this.abstract_ = castToBoolean(value); // BooleanType
3490          return value;
3491        case 24665195: // inactive
3492          this.inactive = castToBoolean(value); // BooleanType
3493          return value;
3494        case 351608024: // version
3495          this.version = castToString(value); // StringType
3496          return value;
3497        case 3059181: // code
3498          this.code = castToCode(value); // CodeType
3499          return value;
3500        case 1671764162: // display
3501          this.display = castToString(value); // StringType
3502          return value;
3503        case -900931593: // designation
3504          this.getDesignation().add((ConceptReferenceDesignationComponent) value); // ConceptReferenceDesignationComponent
3505          return value;
3506        case -567445985: // contains
3507          this.getContains().add((ValueSetExpansionContainsComponent) value); // ValueSetExpansionContainsComponent
3508          return value;
3509        default: return super.setProperty(hash, name, value);
3510        }
3511
3512      }
3513
3514      @Override
3515      public Base setProperty(String name, Base value) throws FHIRException {
3516        if (name.equals("system")) {
3517          this.system = castToUri(value); // UriType
3518        } else if (name.equals("abstract")) {
3519          this.abstract_ = castToBoolean(value); // BooleanType
3520        } else if (name.equals("inactive")) {
3521          this.inactive = castToBoolean(value); // BooleanType
3522        } else if (name.equals("version")) {
3523          this.version = castToString(value); // StringType
3524        } else if (name.equals("code")) {
3525          this.code = castToCode(value); // CodeType
3526        } else if (name.equals("display")) {
3527          this.display = castToString(value); // StringType
3528        } else if (name.equals("designation")) {
3529          this.getDesignation().add((ConceptReferenceDesignationComponent) value);
3530        } else if (name.equals("contains")) {
3531          this.getContains().add((ValueSetExpansionContainsComponent) value);
3532        } else
3533          return super.setProperty(name, value);
3534        return value;
3535      }
3536
3537      @Override
3538      public Base makeProperty(int hash, String name) throws FHIRException {
3539        switch (hash) {
3540        case -887328209:  return getSystemElement();
3541        case 1732898850:  return getAbstractElement();
3542        case 24665195:  return getInactiveElement();
3543        case 351608024:  return getVersionElement();
3544        case 3059181:  return getCodeElement();
3545        case 1671764162:  return getDisplayElement();
3546        case -900931593:  return addDesignation(); 
3547        case -567445985:  return addContains(); 
3548        default: return super.makeProperty(hash, name);
3549        }
3550
3551      }
3552
3553      @Override
3554      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3555        switch (hash) {
3556        case -887328209: /*system*/ return new String[] {"uri"};
3557        case 1732898850: /*abstract*/ return new String[] {"boolean"};
3558        case 24665195: /*inactive*/ return new String[] {"boolean"};
3559        case 351608024: /*version*/ return new String[] {"string"};
3560        case 3059181: /*code*/ return new String[] {"code"};
3561        case 1671764162: /*display*/ return new String[] {"string"};
3562        case -900931593: /*designation*/ return new String[] {"@ValueSet.compose.include.concept.designation"};
3563        case -567445985: /*contains*/ return new String[] {"@ValueSet.expansion.contains"};
3564        default: return super.getTypesForProperty(hash, name);
3565        }
3566
3567      }
3568
3569      @Override
3570      public Base addChild(String name) throws FHIRException {
3571        if (name.equals("system")) {
3572          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.system");
3573        }
3574        else if (name.equals("abstract")) {
3575          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.abstract");
3576        }
3577        else if (name.equals("inactive")) {
3578          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.inactive");
3579        }
3580        else if (name.equals("version")) {
3581          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.version");
3582        }
3583        else if (name.equals("code")) {
3584          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.code");
3585        }
3586        else if (name.equals("display")) {
3587          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.display");
3588        }
3589        else if (name.equals("designation")) {
3590          return addDesignation();
3591        }
3592        else if (name.equals("contains")) {
3593          return addContains();
3594        }
3595        else
3596          return super.addChild(name);
3597      }
3598
3599      public ValueSetExpansionContainsComponent copy() {
3600        ValueSetExpansionContainsComponent dst = new ValueSetExpansionContainsComponent();
3601        copyValues(dst);
3602        dst.system = system == null ? null : system.copy();
3603        dst.abstract_ = abstract_ == null ? null : abstract_.copy();
3604        dst.inactive = inactive == null ? null : inactive.copy();
3605        dst.version = version == null ? null : version.copy();
3606        dst.code = code == null ? null : code.copy();
3607        dst.display = display == null ? null : display.copy();
3608        if (designation != null) {
3609          dst.designation = new ArrayList<ConceptReferenceDesignationComponent>();
3610          for (ConceptReferenceDesignationComponent i : designation)
3611            dst.designation.add(i.copy());
3612        };
3613        if (contains != null) {
3614          dst.contains = new ArrayList<ValueSetExpansionContainsComponent>();
3615          for (ValueSetExpansionContainsComponent i : contains)
3616            dst.contains.add(i.copy());
3617        };
3618        return dst;
3619      }
3620
3621      @Override
3622      public boolean equalsDeep(Base other_) {
3623        if (!super.equalsDeep(other_))
3624          return false;
3625        if (!(other_ instanceof ValueSetExpansionContainsComponent))
3626          return false;
3627        ValueSetExpansionContainsComponent o = (ValueSetExpansionContainsComponent) other_;
3628        return compareDeep(system, o.system, true) && compareDeep(abstract_, o.abstract_, true) && compareDeep(inactive, o.inactive, true)
3629           && compareDeep(version, o.version, true) && compareDeep(code, o.code, true) && compareDeep(display, o.display, true)
3630           && compareDeep(designation, o.designation, true) && compareDeep(contains, o.contains, true);
3631      }
3632
3633      @Override
3634      public boolean equalsShallow(Base other_) {
3635        if (!super.equalsShallow(other_))
3636          return false;
3637        if (!(other_ instanceof ValueSetExpansionContainsComponent))
3638          return false;
3639        ValueSetExpansionContainsComponent o = (ValueSetExpansionContainsComponent) other_;
3640        return compareValues(system, o.system, true) && compareValues(abstract_, o.abstract_, true) && compareValues(inactive, o.inactive, true)
3641           && compareValues(version, o.version, true) && compareValues(code, o.code, true) && compareValues(display, o.display, true)
3642          ;
3643      }
3644
3645      public boolean isEmpty() {
3646        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(system, abstract_, inactive
3647          , version, code, display, designation, contains);
3648      }
3649
3650  public String fhirType() {
3651    return "ValueSet.expansion.contains";
3652
3653  }
3654
3655  }
3656
3657    /**
3658     * A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.
3659     */
3660    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3661    @Description(shortDefinition="Additional identifier for the value set", formalDefinition="A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance." )
3662    protected List<Identifier> identifier;
3663
3664    /**
3665     * If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.
3666     */
3667    @Child(name = "immutable", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=true)
3668    @Description(shortDefinition="Indicates whether or not any change to the content logical definition may occur", formalDefinition="If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change." )
3669    protected BooleanType immutable;
3670
3671    /**
3672     * Explaination of why this value set is needed and why it has been designed as it has.
3673     */
3674    @Child(name = "purpose", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
3675    @Description(shortDefinition="Why this value set is defined", formalDefinition="Explaination of why this value set is needed and why it has been designed as it has." )
3676    protected MarkdownType purpose;
3677
3678    /**
3679     * A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.
3680     */
3681    @Child(name = "copyright", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false)
3682    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set." )
3683    protected MarkdownType copyright;
3684
3685    /**
3686     * Whether this is intended to be used with an extensible binding or not.
3687     */
3688    @Child(name = "extensible", type = {BooleanType.class}, order=4, min=0, max=1, modifier=false, summary=true)
3689    @Description(shortDefinition="Whether this is intended to be used with an extensible binding", formalDefinition="Whether this is intended to be used with an extensible binding or not." )
3690    protected BooleanType extensible;
3691
3692    /**
3693     * A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the "Content Logical Definition" (CLD).
3694     */
3695    @Child(name = "compose", type = {}, order=5, min=0, max=1, modifier=false, summary=false)
3696    @Description(shortDefinition="Definition of the content of the value set (CLD)", formalDefinition="A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the \"Content Logical Definition\" (CLD)." )
3697    protected ValueSetComposeComponent compose;
3698
3699    /**
3700     * A value set can also be "expanded", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.
3701     */
3702    @Child(name = "expansion", type = {}, order=6, min=0, max=1, modifier=false, summary=false)
3703    @Description(shortDefinition="Used when the value set is \"expanded\"", formalDefinition="A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed." )
3704    protected ValueSetExpansionComponent expansion;
3705
3706    private static final long serialVersionUID = -173192200L;
3707
3708  /**
3709   * Constructor
3710   */
3711    public ValueSet() {
3712      super();
3713    }
3714
3715  /**
3716   * Constructor
3717   */
3718    public ValueSet(Enumeration<PublicationStatus> status) {
3719      super();
3720      this.status = status;
3721    }
3722
3723    /**
3724     * @return {@link #url} (An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
3725     */
3726    public UriType getUrlElement() { 
3727      if (this.url == null)
3728        if (Configuration.errorOnAutoCreate())
3729          throw new Error("Attempt to auto-create ValueSet.url");
3730        else if (Configuration.doAutoCreate())
3731          this.url = new UriType(); // bb
3732      return this.url;
3733    }
3734
3735    public boolean hasUrlElement() { 
3736      return this.url != null && !this.url.isEmpty();
3737    }
3738
3739    public boolean hasUrl() { 
3740      return this.url != null && !this.url.isEmpty();
3741    }
3742
3743    /**
3744     * @param value {@link #url} (An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
3745     */
3746    public ValueSet setUrlElement(UriType value) { 
3747      this.url = value;
3748      return this;
3749    }
3750
3751    /**
3752     * @return An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).
3753     */
3754    public String getUrl() { 
3755      return this.url == null ? null : this.url.getValue();
3756    }
3757
3758    /**
3759     * @param value An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).
3760     */
3761    public ValueSet setUrl(String value) { 
3762      if (Utilities.noString(value))
3763        this.url = null;
3764      else {
3765        if (this.url == null)
3766          this.url = new UriType();
3767        this.url.setValue(value);
3768      }
3769      return this;
3770    }
3771
3772    /**
3773     * @return {@link #identifier} (A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.)
3774     */
3775    public List<Identifier> getIdentifier() { 
3776      if (this.identifier == null)
3777        this.identifier = new ArrayList<Identifier>();
3778      return this.identifier;
3779    }
3780
3781    /**
3782     * @return Returns a reference to <code>this</code> for easy method chaining
3783     */
3784    public ValueSet setIdentifier(List<Identifier> theIdentifier) { 
3785      this.identifier = theIdentifier;
3786      return this;
3787    }
3788
3789    public boolean hasIdentifier() { 
3790      if (this.identifier == null)
3791        return false;
3792      for (Identifier item : this.identifier)
3793        if (!item.isEmpty())
3794          return true;
3795      return false;
3796    }
3797
3798    public Identifier addIdentifier() { //3
3799      Identifier t = new Identifier();
3800      if (this.identifier == null)
3801        this.identifier = new ArrayList<Identifier>();
3802      this.identifier.add(t);
3803      return t;
3804    }
3805
3806    public ValueSet addIdentifier(Identifier t) { //3
3807      if (t == null)
3808        return this;
3809      if (this.identifier == null)
3810        this.identifier = new ArrayList<Identifier>();
3811      this.identifier.add(t);
3812      return this;
3813    }
3814
3815    /**
3816     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
3817     */
3818    public Identifier getIdentifierFirstRep() { 
3819      if (getIdentifier().isEmpty()) {
3820        addIdentifier();
3821      }
3822      return getIdentifier().get(0);
3823    }
3824
3825    /**
3826     * @return {@link #version} (The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
3827     */
3828    public StringType getVersionElement() { 
3829      if (this.version == null)
3830        if (Configuration.errorOnAutoCreate())
3831          throw new Error("Attempt to auto-create ValueSet.version");
3832        else if (Configuration.doAutoCreate())
3833          this.version = new StringType(); // bb
3834      return this.version;
3835    }
3836
3837    public boolean hasVersionElement() { 
3838      return this.version != null && !this.version.isEmpty();
3839    }
3840
3841    public boolean hasVersion() { 
3842      return this.version != null && !this.version.isEmpty();
3843    }
3844
3845    /**
3846     * @param value {@link #version} (The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
3847     */
3848    public ValueSet setVersionElement(StringType value) { 
3849      this.version = value;
3850      return this;
3851    }
3852
3853    /**
3854     * @return The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
3855     */
3856    public String getVersion() { 
3857      return this.version == null ? null : this.version.getValue();
3858    }
3859
3860    /**
3861     * @param value The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
3862     */
3863    public ValueSet setVersion(String value) { 
3864      if (Utilities.noString(value))
3865        this.version = null;
3866      else {
3867        if (this.version == null)
3868          this.version = new StringType();
3869        this.version.setValue(value);
3870      }
3871      return this;
3872    }
3873
3874    /**
3875     * @return {@link #name} (A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3876     */
3877    public StringType getNameElement() { 
3878      if (this.name == null)
3879        if (Configuration.errorOnAutoCreate())
3880          throw new Error("Attempt to auto-create ValueSet.name");
3881        else if (Configuration.doAutoCreate())
3882          this.name = new StringType(); // bb
3883      return this.name;
3884    }
3885
3886    public boolean hasNameElement() { 
3887      return this.name != null && !this.name.isEmpty();
3888    }
3889
3890    public boolean hasName() { 
3891      return this.name != null && !this.name.isEmpty();
3892    }
3893
3894    /**
3895     * @param value {@link #name} (A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3896     */
3897    public ValueSet setNameElement(StringType value) { 
3898      this.name = value;
3899      return this;
3900    }
3901
3902    /**
3903     * @return A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.
3904     */
3905    public String getName() { 
3906      return this.name == null ? null : this.name.getValue();
3907    }
3908
3909    /**
3910     * @param value A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.
3911     */
3912    public ValueSet setName(String value) { 
3913      if (Utilities.noString(value))
3914        this.name = null;
3915      else {
3916        if (this.name == null)
3917          this.name = new StringType();
3918        this.name.setValue(value);
3919      }
3920      return this;
3921    }
3922
3923    /**
3924     * @return {@link #title} (A short, descriptive, user-friendly title for the value set.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
3925     */
3926    public StringType getTitleElement() { 
3927      if (this.title == null)
3928        if (Configuration.errorOnAutoCreate())
3929          throw new Error("Attempt to auto-create ValueSet.title");
3930        else if (Configuration.doAutoCreate())
3931          this.title = new StringType(); // bb
3932      return this.title;
3933    }
3934
3935    public boolean hasTitleElement() { 
3936      return this.title != null && !this.title.isEmpty();
3937    }
3938
3939    public boolean hasTitle() { 
3940      return this.title != null && !this.title.isEmpty();
3941    }
3942
3943    /**
3944     * @param value {@link #title} (A short, descriptive, user-friendly title for the value set.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
3945     */
3946    public ValueSet setTitleElement(StringType value) { 
3947      this.title = value;
3948      return this;
3949    }
3950
3951    /**
3952     * @return A short, descriptive, user-friendly title for the value set.
3953     */
3954    public String getTitle() { 
3955      return this.title == null ? null : this.title.getValue();
3956    }
3957
3958    /**
3959     * @param value A short, descriptive, user-friendly title for the value set.
3960     */
3961    public ValueSet setTitle(String value) { 
3962      if (Utilities.noString(value))
3963        this.title = null;
3964      else {
3965        if (this.title == null)
3966          this.title = new StringType();
3967        this.title.setValue(value);
3968      }
3969      return this;
3970    }
3971
3972    /**
3973     * @return {@link #status} (The status of this value set. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
3974     */
3975    public Enumeration<PublicationStatus> getStatusElement() { 
3976      if (this.status == null)
3977        if (Configuration.errorOnAutoCreate())
3978          throw new Error("Attempt to auto-create ValueSet.status");
3979        else if (Configuration.doAutoCreate())
3980          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
3981      return this.status;
3982    }
3983
3984    public boolean hasStatusElement() { 
3985      return this.status != null && !this.status.isEmpty();
3986    }
3987
3988    public boolean hasStatus() { 
3989      return this.status != null && !this.status.isEmpty();
3990    }
3991
3992    /**
3993     * @param value {@link #status} (The status of this value set. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
3994     */
3995    public ValueSet setStatusElement(Enumeration<PublicationStatus> value) { 
3996      this.status = value;
3997      return this;
3998    }
3999
4000    /**
4001     * @return The status of this value set. Enables tracking the life-cycle of the content.
4002     */
4003    public PublicationStatus getStatus() { 
4004      return this.status == null ? null : this.status.getValue();
4005    }
4006
4007    /**
4008     * @param value The status of this value set. Enables tracking the life-cycle of the content.
4009     */
4010    public ValueSet setStatus(PublicationStatus value) { 
4011        if (this.status == null)
4012          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
4013        this.status.setValue(value);
4014      return this;
4015    }
4016
4017    /**
4018     * @return {@link #experimental} (A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
4019     */
4020    public BooleanType getExperimentalElement() { 
4021      if (this.experimental == null)
4022        if (Configuration.errorOnAutoCreate())
4023          throw new Error("Attempt to auto-create ValueSet.experimental");
4024        else if (Configuration.doAutoCreate())
4025          this.experimental = new BooleanType(); // bb
4026      return this.experimental;
4027    }
4028
4029    public boolean hasExperimentalElement() { 
4030      return this.experimental != null && !this.experimental.isEmpty();
4031    }
4032
4033    public boolean hasExperimental() { 
4034      return this.experimental != null && !this.experimental.isEmpty();
4035    }
4036
4037    /**
4038     * @param value {@link #experimental} (A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
4039     */
4040    public ValueSet setExperimentalElement(BooleanType value) { 
4041      this.experimental = value;
4042      return this;
4043    }
4044
4045    /**
4046     * @return A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
4047     */
4048    public boolean getExperimental() { 
4049      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
4050    }
4051
4052    /**
4053     * @param value A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
4054     */
4055    public ValueSet setExperimental(boolean value) { 
4056        if (this.experimental == null)
4057          this.experimental = new BooleanType();
4058        this.experimental.setValue(value);
4059      return this;
4060    }
4061
4062    /**
4063     * @return {@link #date} (The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
4064     */
4065    public DateTimeType getDateElement() { 
4066      if (this.date == null)
4067        if (Configuration.errorOnAutoCreate())
4068          throw new Error("Attempt to auto-create ValueSet.date");
4069        else if (Configuration.doAutoCreate())
4070          this.date = new DateTimeType(); // bb
4071      return this.date;
4072    }
4073
4074    public boolean hasDateElement() { 
4075      return this.date != null && !this.date.isEmpty();
4076    }
4077
4078    public boolean hasDate() { 
4079      return this.date != null && !this.date.isEmpty();
4080    }
4081
4082    /**
4083     * @param value {@link #date} (The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
4084     */
4085    public ValueSet setDateElement(DateTimeType value) { 
4086      this.date = value;
4087      return this;
4088    }
4089
4090    /**
4091     * @return The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').
4092     */
4093    public Date getDate() { 
4094      return this.date == null ? null : this.date.getValue();
4095    }
4096
4097    /**
4098     * @param value The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').
4099     */
4100    public ValueSet setDate(Date value) { 
4101      if (value == null)
4102        this.date = null;
4103      else {
4104        if (this.date == null)
4105          this.date = new DateTimeType();
4106        this.date.setValue(value);
4107      }
4108      return this;
4109    }
4110
4111    /**
4112     * @return {@link #publisher} (The name of the individual or organization that published the value set.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
4113     */
4114    public StringType getPublisherElement() { 
4115      if (this.publisher == null)
4116        if (Configuration.errorOnAutoCreate())
4117          throw new Error("Attempt to auto-create ValueSet.publisher");
4118        else if (Configuration.doAutoCreate())
4119          this.publisher = new StringType(); // bb
4120      return this.publisher;
4121    }
4122
4123    public boolean hasPublisherElement() { 
4124      return this.publisher != null && !this.publisher.isEmpty();
4125    }
4126
4127    public boolean hasPublisher() { 
4128      return this.publisher != null && !this.publisher.isEmpty();
4129    }
4130
4131    /**
4132     * @param value {@link #publisher} (The name of the individual or organization that published the value set.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
4133     */
4134    public ValueSet setPublisherElement(StringType value) { 
4135      this.publisher = value;
4136      return this;
4137    }
4138
4139    /**
4140     * @return The name of the individual or organization that published the value set.
4141     */
4142    public String getPublisher() { 
4143      return this.publisher == null ? null : this.publisher.getValue();
4144    }
4145
4146    /**
4147     * @param value The name of the individual or organization that published the value set.
4148     */
4149    public ValueSet setPublisher(String value) { 
4150      if (Utilities.noString(value))
4151        this.publisher = null;
4152      else {
4153        if (this.publisher == null)
4154          this.publisher = new StringType();
4155        this.publisher.setValue(value);
4156      }
4157      return this;
4158    }
4159
4160    /**
4161     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
4162     */
4163    public List<ContactDetail> getContact() { 
4164      if (this.contact == null)
4165        this.contact = new ArrayList<ContactDetail>();
4166      return this.contact;
4167    }
4168
4169    /**
4170     * @return Returns a reference to <code>this</code> for easy method chaining
4171     */
4172    public ValueSet setContact(List<ContactDetail> theContact) { 
4173      this.contact = theContact;
4174      return this;
4175    }
4176
4177    public boolean hasContact() { 
4178      if (this.contact == null)
4179        return false;
4180      for (ContactDetail item : this.contact)
4181        if (!item.isEmpty())
4182          return true;
4183      return false;
4184    }
4185
4186    public ContactDetail addContact() { //3
4187      ContactDetail t = new ContactDetail();
4188      if (this.contact == null)
4189        this.contact = new ArrayList<ContactDetail>();
4190      this.contact.add(t);
4191      return t;
4192    }
4193
4194    public ValueSet addContact(ContactDetail t) { //3
4195      if (t == null)
4196        return this;
4197      if (this.contact == null)
4198        this.contact = new ArrayList<ContactDetail>();
4199      this.contact.add(t);
4200      return this;
4201    }
4202
4203    /**
4204     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
4205     */
4206    public ContactDetail getContactFirstRep() { 
4207      if (getContact().isEmpty()) {
4208        addContact();
4209      }
4210      return getContact().get(0);
4211    }
4212
4213    /**
4214     * @return {@link #description} (A free text natural language description of the value set from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4215     */
4216    public MarkdownType getDescriptionElement() { 
4217      if (this.description == null)
4218        if (Configuration.errorOnAutoCreate())
4219          throw new Error("Attempt to auto-create ValueSet.description");
4220        else if (Configuration.doAutoCreate())
4221          this.description = new MarkdownType(); // bb
4222      return this.description;
4223    }
4224
4225    public boolean hasDescriptionElement() { 
4226      return this.description != null && !this.description.isEmpty();
4227    }
4228
4229    public boolean hasDescription() { 
4230      return this.description != null && !this.description.isEmpty();
4231    }
4232
4233    /**
4234     * @param value {@link #description} (A free text natural language description of the value set from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4235     */
4236    public ValueSet setDescriptionElement(MarkdownType value) { 
4237      this.description = value;
4238      return this;
4239    }
4240
4241    /**
4242     * @return A free text natural language description of the value set from a consumer's perspective.
4243     */
4244    public String getDescription() { 
4245      return this.description == null ? null : this.description.getValue();
4246    }
4247
4248    /**
4249     * @param value A free text natural language description of the value set from a consumer's perspective.
4250     */
4251    public ValueSet setDescription(String value) { 
4252      if (value == null)
4253        this.description = null;
4254      else {
4255        if (this.description == null)
4256          this.description = new MarkdownType();
4257        this.description.setValue(value);
4258      }
4259      return this;
4260    }
4261
4262    /**
4263     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate value set instances.)
4264     */
4265    public List<UsageContext> getUseContext() { 
4266      if (this.useContext == null)
4267        this.useContext = new ArrayList<UsageContext>();
4268      return this.useContext;
4269    }
4270
4271    /**
4272     * @return Returns a reference to <code>this</code> for easy method chaining
4273     */
4274    public ValueSet setUseContext(List<UsageContext> theUseContext) { 
4275      this.useContext = theUseContext;
4276      return this;
4277    }
4278
4279    public boolean hasUseContext() { 
4280      if (this.useContext == null)
4281        return false;
4282      for (UsageContext item : this.useContext)
4283        if (!item.isEmpty())
4284          return true;
4285      return false;
4286    }
4287
4288    public UsageContext addUseContext() { //3
4289      UsageContext t = new UsageContext();
4290      if (this.useContext == null)
4291        this.useContext = new ArrayList<UsageContext>();
4292      this.useContext.add(t);
4293      return t;
4294    }
4295
4296    public ValueSet addUseContext(UsageContext t) { //3
4297      if (t == null)
4298        return this;
4299      if (this.useContext == null)
4300        this.useContext = new ArrayList<UsageContext>();
4301      this.useContext.add(t);
4302      return this;
4303    }
4304
4305    /**
4306     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist
4307     */
4308    public UsageContext getUseContextFirstRep() { 
4309      if (getUseContext().isEmpty()) {
4310        addUseContext();
4311      }
4312      return getUseContext().get(0);
4313    }
4314
4315    /**
4316     * @return {@link #jurisdiction} (A legal or geographic region in which the value set is intended to be used.)
4317     */
4318    public List<CodeableConcept> getJurisdiction() { 
4319      if (this.jurisdiction == null)
4320        this.jurisdiction = new ArrayList<CodeableConcept>();
4321      return this.jurisdiction;
4322    }
4323
4324    /**
4325     * @return Returns a reference to <code>this</code> for easy method chaining
4326     */
4327    public ValueSet setJurisdiction(List<CodeableConcept> theJurisdiction) { 
4328      this.jurisdiction = theJurisdiction;
4329      return this;
4330    }
4331
4332    public boolean hasJurisdiction() { 
4333      if (this.jurisdiction == null)
4334        return false;
4335      for (CodeableConcept item : this.jurisdiction)
4336        if (!item.isEmpty())
4337          return true;
4338      return false;
4339    }
4340
4341    public CodeableConcept addJurisdiction() { //3
4342      CodeableConcept t = new CodeableConcept();
4343      if (this.jurisdiction == null)
4344        this.jurisdiction = new ArrayList<CodeableConcept>();
4345      this.jurisdiction.add(t);
4346      return t;
4347    }
4348
4349    public ValueSet addJurisdiction(CodeableConcept t) { //3
4350      if (t == null)
4351        return this;
4352      if (this.jurisdiction == null)
4353        this.jurisdiction = new ArrayList<CodeableConcept>();
4354      this.jurisdiction.add(t);
4355      return this;
4356    }
4357
4358    /**
4359     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist
4360     */
4361    public CodeableConcept getJurisdictionFirstRep() { 
4362      if (getJurisdiction().isEmpty()) {
4363        addJurisdiction();
4364      }
4365      return getJurisdiction().get(0);
4366    }
4367
4368    /**
4369     * @return {@link #immutable} (If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.). This is the underlying object with id, value and extensions. The accessor "getImmutable" gives direct access to the value
4370     */
4371    public BooleanType getImmutableElement() { 
4372      if (this.immutable == null)
4373        if (Configuration.errorOnAutoCreate())
4374          throw new Error("Attempt to auto-create ValueSet.immutable");
4375        else if (Configuration.doAutoCreate())
4376          this.immutable = new BooleanType(); // bb
4377      return this.immutable;
4378    }
4379
4380    public boolean hasImmutableElement() { 
4381      return this.immutable != null && !this.immutable.isEmpty();
4382    }
4383
4384    public boolean hasImmutable() { 
4385      return this.immutable != null && !this.immutable.isEmpty();
4386    }
4387
4388    /**
4389     * @param value {@link #immutable} (If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.). This is the underlying object with id, value and extensions. The accessor "getImmutable" gives direct access to the value
4390     */
4391    public ValueSet setImmutableElement(BooleanType value) { 
4392      this.immutable = value;
4393      return this;
4394    }
4395
4396    /**
4397     * @return If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.
4398     */
4399    public boolean getImmutable() { 
4400      return this.immutable == null || this.immutable.isEmpty() ? false : this.immutable.getValue();
4401    }
4402
4403    /**
4404     * @param value If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.
4405     */
4406    public ValueSet setImmutable(boolean value) { 
4407        if (this.immutable == null)
4408          this.immutable = new BooleanType();
4409        this.immutable.setValue(value);
4410      return this;
4411    }
4412
4413    /**
4414     * @return {@link #purpose} (Explaination of why this value set is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
4415     */
4416    public MarkdownType getPurposeElement() { 
4417      if (this.purpose == null)
4418        if (Configuration.errorOnAutoCreate())
4419          throw new Error("Attempt to auto-create ValueSet.purpose");
4420        else if (Configuration.doAutoCreate())
4421          this.purpose = new MarkdownType(); // bb
4422      return this.purpose;
4423    }
4424
4425    public boolean hasPurposeElement() { 
4426      return this.purpose != null && !this.purpose.isEmpty();
4427    }
4428
4429    public boolean hasPurpose() { 
4430      return this.purpose != null && !this.purpose.isEmpty();
4431    }
4432
4433    /**
4434     * @param value {@link #purpose} (Explaination of why this value set is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
4435     */
4436    public ValueSet setPurposeElement(MarkdownType value) { 
4437      this.purpose = value;
4438      return this;
4439    }
4440
4441    /**
4442     * @return Explaination of why this value set is needed and why it has been designed as it has.
4443     */
4444    public String getPurpose() { 
4445      return this.purpose == null ? null : this.purpose.getValue();
4446    }
4447
4448    /**
4449     * @param value Explaination of why this value set is needed and why it has been designed as it has.
4450     */
4451    public ValueSet setPurpose(String value) { 
4452      if (value == null)
4453        this.purpose = null;
4454      else {
4455        if (this.purpose == null)
4456          this.purpose = new MarkdownType();
4457        this.purpose.setValue(value);
4458      }
4459      return this;
4460    }
4461
4462    /**
4463     * @return {@link #copyright} (A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
4464     */
4465    public MarkdownType getCopyrightElement() { 
4466      if (this.copyright == null)
4467        if (Configuration.errorOnAutoCreate())
4468          throw new Error("Attempt to auto-create ValueSet.copyright");
4469        else if (Configuration.doAutoCreate())
4470          this.copyright = new MarkdownType(); // bb
4471      return this.copyright;
4472    }
4473
4474    public boolean hasCopyrightElement() { 
4475      return this.copyright != null && !this.copyright.isEmpty();
4476    }
4477
4478    public boolean hasCopyright() { 
4479      return this.copyright != null && !this.copyright.isEmpty();
4480    }
4481
4482    /**
4483     * @param value {@link #copyright} (A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
4484     */
4485    public ValueSet setCopyrightElement(MarkdownType value) { 
4486      this.copyright = value;
4487      return this;
4488    }
4489
4490    /**
4491     * @return A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.
4492     */
4493    public String getCopyright() { 
4494      return this.copyright == null ? null : this.copyright.getValue();
4495    }
4496
4497    /**
4498     * @param value A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.
4499     */
4500    public ValueSet setCopyright(String value) { 
4501      if (value == null)
4502        this.copyright = null;
4503      else {
4504        if (this.copyright == null)
4505          this.copyright = new MarkdownType();
4506        this.copyright.setValue(value);
4507      }
4508      return this;
4509    }
4510
4511    /**
4512     * @return {@link #extensible} (Whether this is intended to be used with an extensible binding or not.). This is the underlying object with id, value and extensions. The accessor "getExtensible" gives direct access to the value
4513     */
4514    public BooleanType getExtensibleElement() { 
4515      if (this.extensible == null)
4516        if (Configuration.errorOnAutoCreate())
4517          throw new Error("Attempt to auto-create ValueSet.extensible");
4518        else if (Configuration.doAutoCreate())
4519          this.extensible = new BooleanType(); // bb
4520      return this.extensible;
4521    }
4522
4523    public boolean hasExtensibleElement() { 
4524      return this.extensible != null && !this.extensible.isEmpty();
4525    }
4526
4527    public boolean hasExtensible() { 
4528      return this.extensible != null && !this.extensible.isEmpty();
4529    }
4530
4531    /**
4532     * @param value {@link #extensible} (Whether this is intended to be used with an extensible binding or not.). This is the underlying object with id, value and extensions. The accessor "getExtensible" gives direct access to the value
4533     */
4534    public ValueSet setExtensibleElement(BooleanType value) { 
4535      this.extensible = value;
4536      return this;
4537    }
4538
4539    /**
4540     * @return Whether this is intended to be used with an extensible binding or not.
4541     */
4542    public boolean getExtensible() { 
4543      return this.extensible == null || this.extensible.isEmpty() ? false : this.extensible.getValue();
4544    }
4545
4546    /**
4547     * @param value Whether this is intended to be used with an extensible binding or not.
4548     */
4549    public ValueSet setExtensible(boolean value) { 
4550        if (this.extensible == null)
4551          this.extensible = new BooleanType();
4552        this.extensible.setValue(value);
4553      return this;
4554    }
4555
4556    /**
4557     * @return {@link #compose} (A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the "Content Logical Definition" (CLD).)
4558     */
4559    public ValueSetComposeComponent getCompose() { 
4560      if (this.compose == null)
4561        if (Configuration.errorOnAutoCreate())
4562          throw new Error("Attempt to auto-create ValueSet.compose");
4563        else if (Configuration.doAutoCreate())
4564          this.compose = new ValueSetComposeComponent(); // cc
4565      return this.compose;
4566    }
4567
4568    public boolean hasCompose() { 
4569      return this.compose != null && !this.compose.isEmpty();
4570    }
4571
4572    /**
4573     * @param value {@link #compose} (A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the "Content Logical Definition" (CLD).)
4574     */
4575    public ValueSet setCompose(ValueSetComposeComponent value)  { 
4576      this.compose = value;
4577      return this;
4578    }
4579
4580    /**
4581     * @return {@link #expansion} (A value set can also be "expanded", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.)
4582     */
4583    public ValueSetExpansionComponent getExpansion() { 
4584      if (this.expansion == null)
4585        if (Configuration.errorOnAutoCreate())
4586          throw new Error("Attempt to auto-create ValueSet.expansion");
4587        else if (Configuration.doAutoCreate())
4588          this.expansion = new ValueSetExpansionComponent(); // cc
4589      return this.expansion;
4590    }
4591
4592    public boolean hasExpansion() { 
4593      return this.expansion != null && !this.expansion.isEmpty();
4594    }
4595
4596    /**
4597     * @param value {@link #expansion} (A value set can also be "expanded", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.)
4598     */
4599    public ValueSet setExpansion(ValueSetExpansionComponent value)  { 
4600      this.expansion = value;
4601      return this;
4602    }
4603
4604      protected void listChildren(List<Property> children) {
4605        super.listChildren(children);
4606        children.add(new Property("url", "uri", "An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url));
4607        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
4608        children.add(new Property("version", "string", "The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version));
4609        children.add(new Property("name", "string", "A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
4610        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the value set.", 0, 1, title));
4611        children.add(new Property("status", "code", "The status of this value set. Enables tracking the life-cycle of the content.", 0, 1, status));
4612        children.add(new Property("experimental", "boolean", "A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental));
4613        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').", 0, 1, date));
4614        children.add(new Property("publisher", "string", "The name of the individual or organization that published the value set.", 0, 1, publisher));
4615        children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact));
4616        children.add(new Property("description", "markdown", "A free text natural language description of the value set from a consumer's perspective.", 0, 1, description));
4617        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate value set instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
4618        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the value set is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
4619        children.add(new Property("immutable", "boolean", "If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.", 0, 1, immutable));
4620        children.add(new Property("purpose", "markdown", "Explaination of why this value set is needed and why it has been designed as it has.", 0, 1, purpose));
4621        children.add(new Property("copyright", "markdown", "A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.", 0, 1, copyright));
4622        children.add(new Property("extensible", "boolean", "Whether this is intended to be used with an extensible binding or not.", 0, 1, extensible));
4623        children.add(new Property("compose", "", "A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the \"Content Logical Definition\" (CLD).", 0, 1, compose));
4624        children.add(new Property("expansion", "", "A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.", 0, 1, expansion));
4625      }
4626
4627      @Override
4628      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4629        switch (_hash) {
4630        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url);
4631        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
4632        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version);
4633        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
4634        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the value set.", 0, 1, title);
4635        case -892481550: /*status*/  return new Property("status", "code", "The status of this value set. Enables tracking the life-cycle of the content.", 0, 1, status);
4636        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental);
4637        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').", 0, 1, date);
4638        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the individual or organization that published the value set.", 0, 1, publisher);
4639        case 951526432: /*contact*/  return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact);
4640        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the value set from a consumer's perspective.", 0, 1, description);
4641        case -669707736: /*useContext*/  return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate value set instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
4642        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the value set is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
4643        case 1596987778: /*immutable*/  return new Property("immutable", "boolean", "If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.", 0, 1, immutable);
4644        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explaination of why this value set is needed and why it has been designed as it has.", 0, 1, purpose);
4645        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.", 0, 1, copyright);
4646        case -1809433861: /*extensible*/  return new Property("extensible", "boolean", "Whether this is intended to be used with an extensible binding or not.", 0, 1, extensible);
4647        case 950497682: /*compose*/  return new Property("compose", "", "A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the \"Content Logical Definition\" (CLD).", 0, 1, compose);
4648        case 17878207: /*expansion*/  return new Property("expansion", "", "A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.", 0, 1, expansion);
4649        default: return super.getNamedProperty(_hash, _name, _checkValid);
4650        }
4651
4652      }
4653
4654      @Override
4655      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4656        switch (hash) {
4657        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
4658        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
4659        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
4660        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
4661        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
4662        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
4663        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
4664        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
4665        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
4666        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
4667        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
4668        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
4669        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
4670        case 1596987778: /*immutable*/ return this.immutable == null ? new Base[0] : new Base[] {this.immutable}; // BooleanType
4671        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
4672        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
4673        case -1809433861: /*extensible*/ return this.extensible == null ? new Base[0] : new Base[] {this.extensible}; // BooleanType
4674        case 950497682: /*compose*/ return this.compose == null ? new Base[0] : new Base[] {this.compose}; // ValueSetComposeComponent
4675        case 17878207: /*expansion*/ return this.expansion == null ? new Base[0] : new Base[] {this.expansion}; // ValueSetExpansionComponent
4676        default: return super.getProperty(hash, name, checkValid);
4677        }
4678
4679      }
4680
4681      @Override
4682      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4683        switch (hash) {
4684        case 116079: // url
4685          this.url = castToUri(value); // UriType
4686          return value;
4687        case -1618432855: // identifier
4688          this.getIdentifier().add(castToIdentifier(value)); // Identifier
4689          return value;
4690        case 351608024: // version
4691          this.version = castToString(value); // StringType
4692          return value;
4693        case 3373707: // name
4694          this.name = castToString(value); // StringType
4695          return value;
4696        case 110371416: // title
4697          this.title = castToString(value); // StringType
4698          return value;
4699        case -892481550: // status
4700          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
4701          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
4702          return value;
4703        case -404562712: // experimental
4704          this.experimental = castToBoolean(value); // BooleanType
4705          return value;
4706        case 3076014: // date
4707          this.date = castToDateTime(value); // DateTimeType
4708          return value;
4709        case 1447404028: // publisher
4710          this.publisher = castToString(value); // StringType
4711          return value;
4712        case 951526432: // contact
4713          this.getContact().add(castToContactDetail(value)); // ContactDetail
4714          return value;
4715        case -1724546052: // description
4716          this.description = castToMarkdown(value); // MarkdownType
4717          return value;
4718        case -669707736: // useContext
4719          this.getUseContext().add(castToUsageContext(value)); // UsageContext
4720          return value;
4721        case -507075711: // jurisdiction
4722          this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
4723          return value;
4724        case 1596987778: // immutable
4725          this.immutable = castToBoolean(value); // BooleanType
4726          return value;
4727        case -220463842: // purpose
4728          this.purpose = castToMarkdown(value); // MarkdownType
4729          return value;
4730        case 1522889671: // copyright
4731          this.copyright = castToMarkdown(value); // MarkdownType
4732          return value;
4733        case -1809433861: // extensible
4734          this.extensible = castToBoolean(value); // BooleanType
4735          return value;
4736        case 950497682: // compose
4737          this.compose = (ValueSetComposeComponent) value; // ValueSetComposeComponent
4738          return value;
4739        case 17878207: // expansion
4740          this.expansion = (ValueSetExpansionComponent) value; // ValueSetExpansionComponent
4741          return value;
4742        default: return super.setProperty(hash, name, value);
4743        }
4744
4745      }
4746
4747      @Override
4748      public Base setProperty(String name, Base value) throws FHIRException {
4749        if (name.equals("url")) {
4750          this.url = castToUri(value); // UriType
4751        } else if (name.equals("identifier")) {
4752          this.getIdentifier().add(castToIdentifier(value));
4753        } else if (name.equals("version")) {
4754          this.version = castToString(value); // StringType
4755        } else if (name.equals("name")) {
4756          this.name = castToString(value); // StringType
4757        } else if (name.equals("title")) {
4758          this.title = castToString(value); // StringType
4759        } else if (name.equals("status")) {
4760          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
4761          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
4762        } else if (name.equals("experimental")) {
4763          this.experimental = castToBoolean(value); // BooleanType
4764        } else if (name.equals("date")) {
4765          this.date = castToDateTime(value); // DateTimeType
4766        } else if (name.equals("publisher")) {
4767          this.publisher = castToString(value); // StringType
4768        } else if (name.equals("contact")) {
4769          this.getContact().add(castToContactDetail(value));
4770        } else if (name.equals("description")) {
4771          this.description = castToMarkdown(value); // MarkdownType
4772        } else if (name.equals("useContext")) {
4773          this.getUseContext().add(castToUsageContext(value));
4774        } else if (name.equals("jurisdiction")) {
4775          this.getJurisdiction().add(castToCodeableConcept(value));
4776        } else if (name.equals("immutable")) {
4777          this.immutable = castToBoolean(value); // BooleanType
4778        } else if (name.equals("purpose")) {
4779          this.purpose = castToMarkdown(value); // MarkdownType
4780        } else if (name.equals("copyright")) {
4781          this.copyright = castToMarkdown(value); // MarkdownType
4782        } else if (name.equals("extensible")) {
4783          this.extensible = castToBoolean(value); // BooleanType
4784        } else if (name.equals("compose")) {
4785          this.compose = (ValueSetComposeComponent) value; // ValueSetComposeComponent
4786        } else if (name.equals("expansion")) {
4787          this.expansion = (ValueSetExpansionComponent) value; // ValueSetExpansionComponent
4788        } else
4789          return super.setProperty(name, value);
4790        return value;
4791      }
4792
4793      @Override
4794      public Base makeProperty(int hash, String name) throws FHIRException {
4795        switch (hash) {
4796        case 116079:  return getUrlElement();
4797        case -1618432855:  return addIdentifier(); 
4798        case 351608024:  return getVersionElement();
4799        case 3373707:  return getNameElement();
4800        case 110371416:  return getTitleElement();
4801        case -892481550:  return getStatusElement();
4802        case -404562712:  return getExperimentalElement();
4803        case 3076014:  return getDateElement();
4804        case 1447404028:  return getPublisherElement();
4805        case 951526432:  return addContact(); 
4806        case -1724546052:  return getDescriptionElement();
4807        case -669707736:  return addUseContext(); 
4808        case -507075711:  return addJurisdiction(); 
4809        case 1596987778:  return getImmutableElement();
4810        case -220463842:  return getPurposeElement();
4811        case 1522889671:  return getCopyrightElement();
4812        case -1809433861:  return getExtensibleElement();
4813        case 950497682:  return getCompose(); 
4814        case 17878207:  return getExpansion(); 
4815        default: return super.makeProperty(hash, name);
4816        }
4817
4818      }
4819
4820      @Override
4821      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4822        switch (hash) {
4823        case 116079: /*url*/ return new String[] {"uri"};
4824        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
4825        case 351608024: /*version*/ return new String[] {"string"};
4826        case 3373707: /*name*/ return new String[] {"string"};
4827        case 110371416: /*title*/ return new String[] {"string"};
4828        case -892481550: /*status*/ return new String[] {"code"};
4829        case -404562712: /*experimental*/ return new String[] {"boolean"};
4830        case 3076014: /*date*/ return new String[] {"dateTime"};
4831        case 1447404028: /*publisher*/ return new String[] {"string"};
4832        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
4833        case -1724546052: /*description*/ return new String[] {"markdown"};
4834        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
4835        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
4836        case 1596987778: /*immutable*/ return new String[] {"boolean"};
4837        case -220463842: /*purpose*/ return new String[] {"markdown"};
4838        case 1522889671: /*copyright*/ return new String[] {"markdown"};
4839        case -1809433861: /*extensible*/ return new String[] {"boolean"};
4840        case 950497682: /*compose*/ return new String[] {};
4841        case 17878207: /*expansion*/ return new String[] {};
4842        default: return super.getTypesForProperty(hash, name);
4843        }
4844
4845      }
4846
4847      @Override
4848      public Base addChild(String name) throws FHIRException {
4849        if (name.equals("url")) {
4850          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.url");
4851        }
4852        else if (name.equals("identifier")) {
4853          return addIdentifier();
4854        }
4855        else if (name.equals("version")) {
4856          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.version");
4857        }
4858        else if (name.equals("name")) {
4859          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.name");
4860        }
4861        else if (name.equals("title")) {
4862          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.title");
4863        }
4864        else if (name.equals("status")) {
4865          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.status");
4866        }
4867        else if (name.equals("experimental")) {
4868          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.experimental");
4869        }
4870        else if (name.equals("date")) {
4871          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.date");
4872        }
4873        else if (name.equals("publisher")) {
4874          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.publisher");
4875        }
4876        else if (name.equals("contact")) {
4877          return addContact();
4878        }
4879        else if (name.equals("description")) {
4880          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.description");
4881        }
4882        else if (name.equals("useContext")) {
4883          return addUseContext();
4884        }
4885        else if (name.equals("jurisdiction")) {
4886          return addJurisdiction();
4887        }
4888        else if (name.equals("immutable")) {
4889          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.immutable");
4890        }
4891        else if (name.equals("purpose")) {
4892          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.purpose");
4893        }
4894        else if (name.equals("copyright")) {
4895          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.copyright");
4896        }
4897        else if (name.equals("extensible")) {
4898          throw new FHIRException("Cannot call addChild on a primitive type ValueSet.extensible");
4899        }
4900        else if (name.equals("compose")) {
4901          this.compose = new ValueSetComposeComponent();
4902          return this.compose;
4903        }
4904        else if (name.equals("expansion")) {
4905          this.expansion = new ValueSetExpansionComponent();
4906          return this.expansion;
4907        }
4908        else
4909          return super.addChild(name);
4910      }
4911
4912  public String fhirType() {
4913    return "ValueSet";
4914
4915  }
4916
4917      public ValueSet copy() {
4918        ValueSet dst = new ValueSet();
4919        copyValues(dst);
4920        dst.url = url == null ? null : url.copy();
4921        if (identifier != null) {
4922          dst.identifier = new ArrayList<Identifier>();
4923          for (Identifier i : identifier)
4924            dst.identifier.add(i.copy());
4925        };
4926        dst.version = version == null ? null : version.copy();
4927        dst.name = name == null ? null : name.copy();
4928        dst.title = title == null ? null : title.copy();
4929        dst.status = status == null ? null : status.copy();
4930        dst.experimental = experimental == null ? null : experimental.copy();
4931        dst.date = date == null ? null : date.copy();
4932        dst.publisher = publisher == null ? null : publisher.copy();
4933        if (contact != null) {
4934          dst.contact = new ArrayList<ContactDetail>();
4935          for (ContactDetail i : contact)
4936            dst.contact.add(i.copy());
4937        };
4938        dst.description = description == null ? null : description.copy();
4939        if (useContext != null) {
4940          dst.useContext = new ArrayList<UsageContext>();
4941          for (UsageContext i : useContext)
4942            dst.useContext.add(i.copy());
4943        };
4944        if (jurisdiction != null) {
4945          dst.jurisdiction = new ArrayList<CodeableConcept>();
4946          for (CodeableConcept i : jurisdiction)
4947            dst.jurisdiction.add(i.copy());
4948        };
4949        dst.immutable = immutable == null ? null : immutable.copy();
4950        dst.purpose = purpose == null ? null : purpose.copy();
4951        dst.copyright = copyright == null ? null : copyright.copy();
4952        dst.extensible = extensible == null ? null : extensible.copy();
4953        dst.compose = compose == null ? null : compose.copy();
4954        dst.expansion = expansion == null ? null : expansion.copy();
4955        return dst;
4956      }
4957
4958      protected ValueSet typedCopy() {
4959        return copy();
4960      }
4961
4962      @Override
4963      public boolean equalsDeep(Base other_) {
4964        if (!super.equalsDeep(other_))
4965          return false;
4966        if (!(other_ instanceof ValueSet))
4967          return false;
4968        ValueSet o = (ValueSet) other_;
4969        return compareDeep(identifier, o.identifier, true) && compareDeep(immutable, o.immutable, true)
4970           && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) && compareDeep(extensible, o.extensible, true)
4971           && compareDeep(compose, o.compose, true) && compareDeep(expansion, o.expansion, true);
4972      }
4973
4974      @Override
4975      public boolean equalsShallow(Base other_) {
4976        if (!super.equalsShallow(other_))
4977          return false;
4978        if (!(other_ instanceof ValueSet))
4979          return false;
4980        ValueSet o = (ValueSet) other_;
4981        return compareValues(immutable, o.immutable, true) && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true)
4982           && compareValues(extensible, o.extensible, true);
4983      }
4984
4985      public boolean isEmpty() {
4986        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, immutable, purpose
4987          , copyright, extensible, compose, expansion);
4988      }
4989
4990  @Override
4991  public ResourceType getResourceType() {
4992    return ResourceType.ValueSet;
4993   }
4994
4995 /**
4996   * Search parameter: <b>date</b>
4997   * <p>
4998   * Description: <b>The value set publication date</b><br>
4999   * Type: <b>date</b><br>
5000   * Path: <b>ValueSet.date</b><br>
5001   * </p>
5002   */
5003  @SearchParamDefinition(name="date", path="ValueSet.date", description="The value set publication date", type="date" )
5004  public static final String SP_DATE = "date";
5005 /**
5006   * <b>Fluent Client</b> search parameter constant for <b>date</b>
5007   * <p>
5008   * Description: <b>The value set publication date</b><br>
5009   * Type: <b>date</b><br>
5010   * Path: <b>ValueSet.date</b><br>
5011   * </p>
5012   */
5013  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
5014
5015 /**
5016   * Search parameter: <b>reference</b>
5017   * <p>
5018   * Description: <b>A code system included or excluded in the value set or an imported value set</b><br>
5019   * Type: <b>uri</b><br>
5020   * Path: <b>ValueSet.compose.include.system</b><br>
5021   * </p>
5022   */
5023  @SearchParamDefinition(name="reference", path="ValueSet.compose.include.system", description="A code system included or excluded in the value set or an imported value set", type="uri" )
5024  public static final String SP_REFERENCE = "reference";
5025 /**
5026   * <b>Fluent Client</b> search parameter constant for <b>reference</b>
5027   * <p>
5028   * Description: <b>A code system included or excluded in the value set or an imported value set</b><br>
5029   * Type: <b>uri</b><br>
5030   * Path: <b>ValueSet.compose.include.system</b><br>
5031   * </p>
5032   */
5033  public static final ca.uhn.fhir.rest.gclient.UriClientParam REFERENCE = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_REFERENCE);
5034
5035 /**
5036   * Search parameter: <b>identifier</b>
5037   * <p>
5038   * Description: <b>External identifier for the value set</b><br>
5039   * Type: <b>token</b><br>
5040   * Path: <b>ValueSet.identifier</b><br>
5041   * </p>
5042   */
5043  @SearchParamDefinition(name="identifier", path="ValueSet.identifier", description="External identifier for the value set", type="token" )
5044  public static final String SP_IDENTIFIER = "identifier";
5045 /**
5046   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
5047   * <p>
5048   * Description: <b>External identifier for the value set</b><br>
5049   * Type: <b>token</b><br>
5050   * Path: <b>ValueSet.identifier</b><br>
5051   * </p>
5052   */
5053  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
5054
5055 /**
5056   * Search parameter: <b>jurisdiction</b>
5057   * <p>
5058   * Description: <b>Intended jurisdiction for the value set</b><br>
5059   * Type: <b>token</b><br>
5060   * Path: <b>ValueSet.jurisdiction</b><br>
5061   * </p>
5062   */
5063  @SearchParamDefinition(name="jurisdiction", path="ValueSet.jurisdiction", description="Intended jurisdiction for the value set", type="token" )
5064  public static final String SP_JURISDICTION = "jurisdiction";
5065 /**
5066   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
5067   * <p>
5068   * Description: <b>Intended jurisdiction for the value set</b><br>
5069   * Type: <b>token</b><br>
5070   * Path: <b>ValueSet.jurisdiction</b><br>
5071   * </p>
5072   */
5073  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
5074
5075 /**
5076   * Search parameter: <b>name</b>
5077   * <p>
5078   * Description: <b>Computationally friendly name of the value set</b><br>
5079   * Type: <b>string</b><br>
5080   * Path: <b>ValueSet.name</b><br>
5081   * </p>
5082   */
5083  @SearchParamDefinition(name="name", path="ValueSet.name", description="Computationally friendly name of the value set", type="string" )
5084  public static final String SP_NAME = "name";
5085 /**
5086   * <b>Fluent Client</b> search parameter constant for <b>name</b>
5087   * <p>
5088   * Description: <b>Computationally friendly name of the value set</b><br>
5089   * Type: <b>string</b><br>
5090   * Path: <b>ValueSet.name</b><br>
5091   * </p>
5092   */
5093  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
5094
5095 /**
5096   * Search parameter: <b>description</b>
5097   * <p>
5098   * Description: <b>The description of the value set</b><br>
5099   * Type: <b>string</b><br>
5100   * Path: <b>ValueSet.description</b><br>
5101   * </p>
5102   */
5103  @SearchParamDefinition(name="description", path="ValueSet.description", description="The description of the value set", type="string" )
5104  public static final String SP_DESCRIPTION = "description";
5105 /**
5106   * <b>Fluent Client</b> search parameter constant for <b>description</b>
5107   * <p>
5108   * Description: <b>The description of the value set</b><br>
5109   * Type: <b>string</b><br>
5110   * Path: <b>ValueSet.description</b><br>
5111   * </p>
5112   */
5113  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
5114
5115 /**
5116   * Search parameter: <b>publisher</b>
5117   * <p>
5118   * Description: <b>Name of the publisher of the value set</b><br>
5119   * Type: <b>string</b><br>
5120   * Path: <b>ValueSet.publisher</b><br>
5121   * </p>
5122   */
5123  @SearchParamDefinition(name="publisher", path="ValueSet.publisher", description="Name of the publisher of the value set", type="string" )
5124  public static final String SP_PUBLISHER = "publisher";
5125 /**
5126   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
5127   * <p>
5128   * Description: <b>Name of the publisher of the value set</b><br>
5129   * Type: <b>string</b><br>
5130   * Path: <b>ValueSet.publisher</b><br>
5131   * </p>
5132   */
5133  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
5134
5135 /**
5136   * Search parameter: <b>title</b>
5137   * <p>
5138   * Description: <b>The human-friendly name of the value set</b><br>
5139   * Type: <b>string</b><br>
5140   * Path: <b>ValueSet.title</b><br>
5141   * </p>
5142   */
5143  @SearchParamDefinition(name="title", path="ValueSet.title", description="The human-friendly name of the value set", type="string" )
5144  public static final String SP_TITLE = "title";
5145 /**
5146   * <b>Fluent Client</b> search parameter constant for <b>title</b>
5147   * <p>
5148   * Description: <b>The human-friendly name of the value set</b><br>
5149   * Type: <b>string</b><br>
5150   * Path: <b>ValueSet.title</b><br>
5151   * </p>
5152   */
5153  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
5154
5155 /**
5156   * Search parameter: <b>version</b>
5157   * <p>
5158   * Description: <b>The business version of the value set</b><br>
5159   * Type: <b>token</b><br>
5160   * Path: <b>ValueSet.version</b><br>
5161   * </p>
5162   */
5163  @SearchParamDefinition(name="version", path="ValueSet.version", description="The business version of the value set", type="token" )
5164  public static final String SP_VERSION = "version";
5165 /**
5166   * <b>Fluent Client</b> search parameter constant for <b>version</b>
5167   * <p>
5168   * Description: <b>The business version of the value set</b><br>
5169   * Type: <b>token</b><br>
5170   * Path: <b>ValueSet.version</b><br>
5171   * </p>
5172   */
5173  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
5174
5175 /**
5176   * Search parameter: <b>url</b>
5177   * <p>
5178   * Description: <b>The uri that identifies the value set</b><br>
5179   * Type: <b>uri</b><br>
5180   * Path: <b>ValueSet.url</b><br>
5181   * </p>
5182   */
5183  @SearchParamDefinition(name="url", path="ValueSet.url", description="The uri that identifies the value set", type="uri" )
5184  public static final String SP_URL = "url";
5185 /**
5186   * <b>Fluent Client</b> search parameter constant for <b>url</b>
5187   * <p>
5188   * Description: <b>The uri that identifies the value set</b><br>
5189   * Type: <b>uri</b><br>
5190   * Path: <b>ValueSet.url</b><br>
5191   * </p>
5192   */
5193  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
5194
5195 /**
5196   * Search parameter: <b>status</b>
5197   * <p>
5198   * Description: <b>The current status of the value set</b><br>
5199   * Type: <b>token</b><br>
5200   * Path: <b>ValueSet.status</b><br>
5201   * </p>
5202   */
5203  @SearchParamDefinition(name="status", path="ValueSet.status", description="The current status of the value set", type="token" )
5204  public static final String SP_STATUS = "status";
5205 /**
5206   * <b>Fluent Client</b> search parameter constant for <b>status</b>
5207   * <p>
5208   * Description: <b>The current status of the value set</b><br>
5209   * Type: <b>token</b><br>
5210   * Path: <b>ValueSet.status</b><br>
5211   * </p>
5212   */
5213  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
5214
5215 /**
5216   * Search parameter: <b>expansion</b>
5217   * <p>
5218   * Description: <b>Uniquely identifies this expansion</b><br>
5219   * Type: <b>uri</b><br>
5220   * Path: <b>ValueSet.expansion.identifier</b><br>
5221   * </p>
5222   */
5223  @SearchParamDefinition(name="expansion", path="ValueSet.expansion.identifier", description="Uniquely identifies this expansion", type="uri" )
5224  public static final String SP_EXPANSION = "expansion";
5225 /**
5226   * <b>Fluent Client</b> search parameter constant for <b>expansion</b>
5227   * <p>
5228   * Description: <b>Uniquely identifies this expansion</b><br>
5229   * Type: <b>uri</b><br>
5230   * Path: <b>ValueSet.expansion.identifier</b><br>
5231   * </p>
5232   */
5233  public static final ca.uhn.fhir.rest.gclient.UriClientParam EXPANSION = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_EXPANSION);
5234
5235
5236}