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