001package org.hl7.fhir.r4.model;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034
035// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1
036
037
038import org.hl7.fhir.instance.model.api.*;
039import org.hl7.fhir.exceptions.FHIRException;
040
041public class Enumerations {
042
043// In here: 
044//   AbstractType: A list of the base types defined by this version of the FHIR specification - types that are defined, but for which only specializations actually are created.
045//   AdministrativeGender: The gender of a person used for administrative purposes.
046//   AgeUnits: A valueSet of UCUM codes for representing age value units.
047//   BindingStrength: Indication of the degree of conformance expectations associated with a binding.
048//   ConceptMapEquivalence: The degree of equivalence between concepts.
049//   DataAbsentReason: Used to specify why the normally expected content of the data element is missing.
050//   DataType: A version specific list of the data types defined by the FHIR specification for use as an element  type (any of the FHIR defined data types).
051//   DefinitionResourceType: A list of all the definition resource types defined in this version of the FHIR specification.
052//   DocumentReferenceStatus: The status of the document reference.
053//   EventResourceType: A list of all the event resource types defined in this version of the FHIR specification.
054//   FHIRAllTypes: A list of all the concrete types defined in this version of the FHIR specification - Abstract Types, Data Types and Resource Types.
055//   FHIRDefinedType: A list of all the concrete types defined in this version of the FHIR specification - Data Types and Resource Types.
056//   FHIRVersion: All published FHIR Versions.
057//   KnowledgeResourceType: A list of all the knowledge resource types defined in this version of the FHIR specification.
058//   MessageEvent: One of the message events defined as part of this version of FHIR.
059//   NoteType: The presentation types of notes.
060//   PublicationStatus: The lifecycle status of an artifact.
061//   RemittanceOutcome: The outcome of the processing.
062//   RequestResourceType: A list of all the request resource types defined in this version of the FHIR specification.
063//   ResourceType: One of the resource types defined as part of this version of FHIR.
064//   SearchParamType: Data types allowed to be used for search parameters.
065//   SpecialValues: A set of generally useful codes defined so they can be included in value sets.
066
067
068    public enum AbstractType {
069        /**
070         * A place holder that means any kind of data type
071         */
072        TYPE, 
073        /**
074         * A place holder that means any kind of resource
075         */
076        ANY, 
077        /**
078         * added to help the parsers
079         */
080        NULL;
081        public static AbstractType fromCode(String codeString) throws FHIRException {
082            if (codeString == null || "".equals(codeString))
083                return null;
084        if ("Type".equals(codeString))
085          return TYPE;
086        if ("Any".equals(codeString))
087          return ANY;
088        throw new FHIRException("Unknown AbstractType code '"+codeString+"'");
089        }
090        public String toCode() {
091          switch (this) {
092            case TYPE: return "Type";
093            case ANY: return "Any";
094            case NULL: return null;
095            default: return "?";
096          }
097        }
098        public String getSystem() {
099          switch (this) {
100            case TYPE: return "http://hl7.org/fhir/abstract-types";
101            case ANY: return "http://hl7.org/fhir/abstract-types";
102            case NULL: return null;
103            default: return "?";
104          }
105        }
106        public String getDefinition() {
107          switch (this) {
108            case TYPE: return "A place holder that means any kind of data type";
109            case ANY: return "A place holder that means any kind of resource";
110            case NULL: return null;
111            default: return "?";
112          }
113        }
114        public String getDisplay() {
115          switch (this) {
116            case TYPE: return "Type";
117            case ANY: return "Any";
118            case NULL: return null;
119            default: return "?";
120          }
121        }
122    }
123
124  public static class AbstractTypeEnumFactory implements EnumFactory<AbstractType> {
125    public AbstractType fromCode(String codeString) throws IllegalArgumentException {
126      if (codeString == null || "".equals(codeString))
127            if (codeString == null || "".equals(codeString))
128                return null;
129        if ("Type".equals(codeString))
130          return AbstractType.TYPE;
131        if ("Any".equals(codeString))
132          return AbstractType.ANY;
133        throw new IllegalArgumentException("Unknown AbstractType code '"+codeString+"'");
134        }
135        public Enumeration<AbstractType> fromType(PrimitiveType<?> code) throws FHIRException {
136          if (code == null)
137            return null;
138          if (code.isEmpty())
139            return new Enumeration<AbstractType>(this, AbstractType.NULL, code);
140          String codeString = code.asStringValue();
141          if (codeString == null || "".equals(codeString))
142            return new Enumeration<AbstractType>(this, AbstractType.NULL, code);
143        if ("Type".equals(codeString))
144          return new Enumeration<AbstractType>(this, AbstractType.TYPE, code);
145        if ("Any".equals(codeString))
146          return new Enumeration<AbstractType>(this, AbstractType.ANY, code);
147        throw new FHIRException("Unknown AbstractType code '"+codeString+"'");
148        }
149    public String toCode(AbstractType code) {
150      if (code == AbstractType.TYPE)
151        return "Type";
152      if (code == AbstractType.ANY)
153        return "Any";
154      return "?";
155      }
156    public String toSystem(AbstractType code) {
157      return code.getSystem();
158      }
159    }
160
161    public enum AdministrativeGender {
162        /**
163         * Male.
164         */
165        MALE, 
166        /**
167         * Female.
168         */
169        FEMALE, 
170        /**
171         * Other.
172         */
173        OTHER, 
174        /**
175         * Unknown.
176         */
177        UNKNOWN, 
178        /**
179         * added to help the parsers
180         */
181        NULL;
182        public static AdministrativeGender fromCode(String codeString) throws FHIRException {
183            if (codeString == null || "".equals(codeString))
184                return null;
185        if ("male".equals(codeString))
186          return MALE;
187        if ("female".equals(codeString))
188          return FEMALE;
189        if ("other".equals(codeString))
190          return OTHER;
191        if ("unknown".equals(codeString))
192          return UNKNOWN;
193        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
194        }
195        public String toCode() {
196          switch (this) {
197            case MALE: return "male";
198            case FEMALE: return "female";
199            case OTHER: return "other";
200            case UNKNOWN: return "unknown";
201            case NULL: return null;
202            default: return "?";
203          }
204        }
205        public String getSystem() {
206          switch (this) {
207            case MALE: return "http://hl7.org/fhir/administrative-gender";
208            case FEMALE: return "http://hl7.org/fhir/administrative-gender";
209            case OTHER: return "http://hl7.org/fhir/administrative-gender";
210            case UNKNOWN: return "http://hl7.org/fhir/administrative-gender";
211            case NULL: return null;
212            default: return "?";
213          }
214        }
215        public String getDefinition() {
216          switch (this) {
217            case MALE: return "Male.";
218            case FEMALE: return "Female.";
219            case OTHER: return "Other.";
220            case UNKNOWN: return "Unknown.";
221            case NULL: return null;
222            default: return "?";
223          }
224        }
225        public String getDisplay() {
226          switch (this) {
227            case MALE: return "Male";
228            case FEMALE: return "Female";
229            case OTHER: return "Other";
230            case UNKNOWN: return "Unknown";
231            case NULL: return null;
232            default: return "?";
233          }
234        }
235    }
236
237  public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> {
238    public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException {
239      if (codeString == null || "".equals(codeString))
240            if (codeString == null || "".equals(codeString))
241                return null;
242        if ("male".equals(codeString))
243          return AdministrativeGender.MALE;
244        if ("female".equals(codeString))
245          return AdministrativeGender.FEMALE;
246        if ("other".equals(codeString))
247          return AdministrativeGender.OTHER;
248        if ("unknown".equals(codeString))
249          return AdministrativeGender.UNKNOWN;
250        throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'");
251        }
252        public Enumeration<AdministrativeGender> fromType(PrimitiveType<?> code) throws FHIRException {
253          if (code == null)
254            return null;
255          if (code.isEmpty())
256            return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code);
257          String codeString = code.asStringValue();
258          if (codeString == null || "".equals(codeString))
259            return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code);
260        if ("male".equals(codeString))
261          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code);
262        if ("female".equals(codeString))
263          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code);
264        if ("other".equals(codeString))
265          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code);
266        if ("unknown".equals(codeString))
267          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code);
268        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
269        }
270    public String toCode(AdministrativeGender code) {
271      if (code == AdministrativeGender.MALE)
272        return "male";
273      if (code == AdministrativeGender.FEMALE)
274        return "female";
275      if (code == AdministrativeGender.OTHER)
276        return "other";
277      if (code == AdministrativeGender.UNKNOWN)
278        return "unknown";
279      return "?";
280      }
281    public String toSystem(AdministrativeGender code) {
282      return code.getSystem();
283      }
284    }
285
286    public enum AgeUnits {
287        /**
288         * null
289         */
290        MIN, 
291        /**
292         * null
293         */
294        H, 
295        /**
296         * null
297         */
298        D, 
299        /**
300         * null
301         */
302        WK, 
303        /**
304         * null
305         */
306        MO, 
307        /**
308         * null
309         */
310        A, 
311        /**
312         * added to help the parsers
313         */
314        NULL;
315        public static AgeUnits fromCode(String codeString) throws FHIRException {
316            if (codeString == null || "".equals(codeString))
317                return null;
318        if ("min".equals(codeString))
319          return MIN;
320        if ("h".equals(codeString))
321          return H;
322        if ("d".equals(codeString))
323          return D;
324        if ("wk".equals(codeString))
325          return WK;
326        if ("mo".equals(codeString))
327          return MO;
328        if ("a".equals(codeString))
329          return A;
330        throw new FHIRException("Unknown AgeUnits code '"+codeString+"'");
331        }
332        public String toCode() {
333          switch (this) {
334            case MIN: return "min";
335            case H: return "h";
336            case D: return "d";
337            case WK: return "wk";
338            case MO: return "mo";
339            case A: return "a";
340            case NULL: return null;
341            default: return "?";
342          }
343        }
344        public String getSystem() {
345          switch (this) {
346            case MIN: return "http://unitsofmeasure.org";
347            case H: return "http://unitsofmeasure.org";
348            case D: return "http://unitsofmeasure.org";
349            case WK: return "http://unitsofmeasure.org";
350            case MO: return "http://unitsofmeasure.org";
351            case A: return "http://unitsofmeasure.org";
352            case NULL: return null;
353            default: return "?";
354          }
355        }
356        public String getDefinition() {
357          switch (this) {
358            case MIN: return "";
359            case H: return "";
360            case D: return "";
361            case WK: return "";
362            case MO: return "";
363            case A: return "";
364            case NULL: return null;
365            default: return "?";
366          }
367        }
368        public String getDisplay() {
369          switch (this) {
370            case MIN: return "Minute";
371            case H: return "Hour";
372            case D: return "Day";
373            case WK: return "Week";
374            case MO: return "Month";
375            case A: return "Year";
376            case NULL: return null;
377            default: return "?";
378          }
379        }
380    }
381
382  public static class AgeUnitsEnumFactory implements EnumFactory<AgeUnits> {
383    public AgeUnits fromCode(String codeString) throws IllegalArgumentException {
384      if (codeString == null || "".equals(codeString))
385            if (codeString == null || "".equals(codeString))
386                return null;
387        if ("min".equals(codeString))
388          return AgeUnits.MIN;
389        if ("h".equals(codeString))
390          return AgeUnits.H;
391        if ("d".equals(codeString))
392          return AgeUnits.D;
393        if ("wk".equals(codeString))
394          return AgeUnits.WK;
395        if ("mo".equals(codeString))
396          return AgeUnits.MO;
397        if ("a".equals(codeString))
398          return AgeUnits.A;
399        throw new IllegalArgumentException("Unknown AgeUnits code '"+codeString+"'");
400        }
401        public Enumeration<AgeUnits> fromType(PrimitiveType<?> code) throws FHIRException {
402          if (code == null)
403            return null;
404          if (code.isEmpty())
405            return new Enumeration<AgeUnits>(this, AgeUnits.NULL, code);
406          String codeString = code.asStringValue();
407          if (codeString == null || "".equals(codeString))
408            return new Enumeration<AgeUnits>(this, AgeUnits.NULL, code);
409        if ("min".equals(codeString))
410          return new Enumeration<AgeUnits>(this, AgeUnits.MIN, code);
411        if ("h".equals(codeString))
412          return new Enumeration<AgeUnits>(this, AgeUnits.H, code);
413        if ("d".equals(codeString))
414          return new Enumeration<AgeUnits>(this, AgeUnits.D, code);
415        if ("wk".equals(codeString))
416          return new Enumeration<AgeUnits>(this, AgeUnits.WK, code);
417        if ("mo".equals(codeString))
418          return new Enumeration<AgeUnits>(this, AgeUnits.MO, code);
419        if ("a".equals(codeString))
420          return new Enumeration<AgeUnits>(this, AgeUnits.A, code);
421        throw new FHIRException("Unknown AgeUnits code '"+codeString+"'");
422        }
423    public String toCode(AgeUnits code) {
424      if (code == AgeUnits.MIN)
425        return "min";
426      if (code == AgeUnits.H)
427        return "h";
428      if (code == AgeUnits.D)
429        return "d";
430      if (code == AgeUnits.WK)
431        return "wk";
432      if (code == AgeUnits.MO)
433        return "mo";
434      if (code == AgeUnits.A)
435        return "a";
436      return "?";
437      }
438    public String toSystem(AgeUnits code) {
439      return code.getSystem();
440      }
441    }
442
443    public enum BindingStrength {
444        /**
445         * To be conformant, the concept in this element SHALL be from the specified value set.
446         */
447        REQUIRED, 
448        /**
449         * To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated.  If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead.
450         */
451        EXTENSIBLE, 
452        /**
453         * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.
454         */
455        PREFERRED, 
456        /**
457         * Instances are not expected or even encouraged to draw from the specified value set.  The value set merely provides examples of the types of concepts intended to be included.
458         */
459        EXAMPLE, 
460        /**
461         * added to help the parsers
462         */
463        NULL;
464        public static BindingStrength fromCode(String codeString) throws FHIRException {
465            if (codeString == null || "".equals(codeString))
466                return null;
467        if ("required".equals(codeString))
468          return REQUIRED;
469        if ("extensible".equals(codeString))
470          return EXTENSIBLE;
471        if ("preferred".equals(codeString))
472          return PREFERRED;
473        if ("example".equals(codeString))
474          return EXAMPLE;
475        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
476        }
477        public String toCode() {
478          switch (this) {
479            case REQUIRED: return "required";
480            case EXTENSIBLE: return "extensible";
481            case PREFERRED: return "preferred";
482            case EXAMPLE: return "example";
483            case NULL: return null;
484            default: return "?";
485          }
486        }
487        public String getSystem() {
488          switch (this) {
489            case REQUIRED: return "http://hl7.org/fhir/binding-strength";
490            case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength";
491            case PREFERRED: return "http://hl7.org/fhir/binding-strength";
492            case EXAMPLE: return "http://hl7.org/fhir/binding-strength";
493            case NULL: return null;
494            default: return "?";
495          }
496        }
497        public String getDefinition() {
498          switch (this) {
499            case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set.";
500            case EXTENSIBLE: return "To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated.  If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead.";
501            case PREFERRED: return "Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.";
502            case EXAMPLE: return "Instances are not expected or even encouraged to draw from the specified value set.  The value set merely provides examples of the types of concepts intended to be included.";
503            case NULL: return null;
504            default: return "?";
505          }
506        }
507        public String getDisplay() {
508          switch (this) {
509            case REQUIRED: return "Required";
510            case EXTENSIBLE: return "Extensible";
511            case PREFERRED: return "Preferred";
512            case EXAMPLE: return "Example";
513            case NULL: return null;
514            default: return "?";
515          }
516        }
517    }
518
519  public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> {
520    public BindingStrength fromCode(String codeString) throws IllegalArgumentException {
521      if (codeString == null || "".equals(codeString))
522            if (codeString == null || "".equals(codeString))
523                return null;
524        if ("required".equals(codeString))
525          return BindingStrength.REQUIRED;
526        if ("extensible".equals(codeString))
527          return BindingStrength.EXTENSIBLE;
528        if ("preferred".equals(codeString))
529          return BindingStrength.PREFERRED;
530        if ("example".equals(codeString))
531          return BindingStrength.EXAMPLE;
532        throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'");
533        }
534        public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException {
535          if (code == null)
536            return null;
537          if (code.isEmpty())
538            return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code);
539          String codeString = code.asStringValue();
540          if (codeString == null || "".equals(codeString))
541            return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code);
542        if ("required".equals(codeString))
543          return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code);
544        if ("extensible".equals(codeString))
545          return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code);
546        if ("preferred".equals(codeString))
547          return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code);
548        if ("example".equals(codeString))
549          return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code);
550        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
551        }
552    public String toCode(BindingStrength code) {
553      if (code == BindingStrength.REQUIRED)
554        return "required";
555      if (code == BindingStrength.EXTENSIBLE)
556        return "extensible";
557      if (code == BindingStrength.PREFERRED)
558        return "preferred";
559      if (code == BindingStrength.EXAMPLE)
560        return "example";
561      return "?";
562      }
563    public String toSystem(BindingStrength code) {
564      return code.getSystem();
565      }
566    }
567
568    public enum ConceptMapEquivalence {
569        /**
570         * The concepts are related to each other, and have at least some overlap in meaning, but the exact relationship is not known.
571         */
572        RELATEDTO, 
573        /**
574         * The definitions of the concepts mean the same thing (including when structural implications of meaning are considered) (i.e. extensionally identical).
575         */
576        EQUIVALENT, 
577        /**
578         * The definitions of the concepts are exactly the same (i.e. only grammatical differences) and structural implications of meaning are identical or irrelevant (i.e. intentionally identical).
579         */
580        EQUAL, 
581        /**
582         * The target mapping is wider in meaning than the source concept.
583         */
584        WIDER, 
585        /**
586         * The target mapping subsumes the meaning of the source concept (e.g. the source is-a target).
587         */
588        SUBSUMES, 
589        /**
590         * The target mapping is narrower in meaning than the source concept. The sense in which the mapping is narrower SHALL be described in the comments in this case, and applications should be careful when attempting to use these mappings operationally.
591         */
592        NARROWER, 
593        /**
594         * The target mapping specializes the meaning of the source concept (e.g. the target is-a source).
595         */
596        SPECIALIZES, 
597        /**
598         * The target mapping overlaps with the source concept, but both source and target cover additional meaning, or the definitions are imprecise and it is uncertain whether they have the same boundaries to their meaning. The sense in which the mapping is inexact SHALL be described in the comments in this case, and applications should be careful when attempting to use these mappings operationally.
599         */
600        INEXACT, 
601        /**
602         * There is no match for this concept in the target code system.
603         */
604        UNMATCHED, 
605        /**
606         * This is an explicit assertion that there is no mapping between the source and target concept.
607         */
608        DISJOINT, 
609        /**
610         * added to help the parsers
611         */
612        NULL;
613        public static ConceptMapEquivalence fromCode(String codeString) throws FHIRException {
614            if (codeString == null || "".equals(codeString))
615                return null;
616        if ("relatedto".equals(codeString))
617          return RELATEDTO;
618        if ("equivalent".equals(codeString))
619          return EQUIVALENT;
620        if ("equal".equals(codeString))
621          return EQUAL;
622        if ("wider".equals(codeString))
623          return WIDER;
624        if ("subsumes".equals(codeString))
625          return SUBSUMES;
626        if ("narrower".equals(codeString))
627          return NARROWER;
628        if ("specializes".equals(codeString))
629          return SPECIALIZES;
630        if ("inexact".equals(codeString))
631          return INEXACT;
632        if ("unmatched".equals(codeString))
633          return UNMATCHED;
634        if ("disjoint".equals(codeString))
635          return DISJOINT;
636        throw new FHIRException("Unknown ConceptMapEquivalence code '"+codeString+"'");
637        }
638        public String toCode() {
639          switch (this) {
640            case RELATEDTO: return "relatedto";
641            case EQUIVALENT: return "equivalent";
642            case EQUAL: return "equal";
643            case WIDER: return "wider";
644            case SUBSUMES: return "subsumes";
645            case NARROWER: return "narrower";
646            case SPECIALIZES: return "specializes";
647            case INEXACT: return "inexact";
648            case UNMATCHED: return "unmatched";
649            case DISJOINT: return "disjoint";
650            case NULL: return null;
651            default: return "?";
652          }
653        }
654        public String getSystem() {
655          switch (this) {
656            case RELATEDTO: return "http://hl7.org/fhir/concept-map-equivalence";
657            case EQUIVALENT: return "http://hl7.org/fhir/concept-map-equivalence";
658            case EQUAL: return "http://hl7.org/fhir/concept-map-equivalence";
659            case WIDER: return "http://hl7.org/fhir/concept-map-equivalence";
660            case SUBSUMES: return "http://hl7.org/fhir/concept-map-equivalence";
661            case NARROWER: return "http://hl7.org/fhir/concept-map-equivalence";
662            case SPECIALIZES: return "http://hl7.org/fhir/concept-map-equivalence";
663            case INEXACT: return "http://hl7.org/fhir/concept-map-equivalence";
664            case UNMATCHED: return "http://hl7.org/fhir/concept-map-equivalence";
665            case DISJOINT: return "http://hl7.org/fhir/concept-map-equivalence";
666            case NULL: return null;
667            default: return "?";
668          }
669        }
670        public String getDefinition() {
671          switch (this) {
672            case RELATEDTO: return "The concepts are related to each other, and have at least some overlap in meaning, but the exact relationship is not known.";
673            case EQUIVALENT: return "The definitions of the concepts mean the same thing (including when structural implications of meaning are considered) (i.e. extensionally identical).";
674            case EQUAL: return "The definitions of the concepts are exactly the same (i.e. only grammatical differences) and structural implications of meaning are identical or irrelevant (i.e. intentionally identical).";
675            case WIDER: return "The target mapping is wider in meaning than the source concept.";
676            case SUBSUMES: return "The target mapping subsumes the meaning of the source concept (e.g. the source is-a target).";
677            case NARROWER: return "The target mapping is narrower in meaning than the source concept. The sense in which the mapping is narrower SHALL be described in the comments in this case, and applications should be careful when attempting to use these mappings operationally.";
678            case SPECIALIZES: return "The target mapping specializes the meaning of the source concept (e.g. the target is-a source).";
679            case INEXACT: return "The target mapping overlaps with the source concept, but both source and target cover additional meaning, or the definitions are imprecise and it is uncertain whether they have the same boundaries to their meaning. The sense in which the mapping is inexact SHALL be described in the comments in this case, and applications should be careful when attempting to use these mappings operationally.";
680            case UNMATCHED: return "There is no match for this concept in the target code system.";
681            case DISJOINT: return "This is an explicit assertion that there is no mapping between the source and target concept.";
682            case NULL: return null;
683            default: return "?";
684          }
685        }
686        public String getDisplay() {
687          switch (this) {
688            case RELATEDTO: return "Related To";
689            case EQUIVALENT: return "Equivalent";
690            case EQUAL: return "Equal";
691            case WIDER: return "Wider";
692            case SUBSUMES: return "Subsumes";
693            case NARROWER: return "Narrower";
694            case SPECIALIZES: return "Specializes";
695            case INEXACT: return "Inexact";
696            case UNMATCHED: return "Unmatched";
697            case DISJOINT: return "Disjoint";
698            case NULL: return null;
699            default: return "?";
700          }
701        }
702    }
703
704  public static class ConceptMapEquivalenceEnumFactory implements EnumFactory<ConceptMapEquivalence> {
705    public ConceptMapEquivalence fromCode(String codeString) throws IllegalArgumentException {
706      if (codeString == null || "".equals(codeString))
707            if (codeString == null || "".equals(codeString))
708                return null;
709        if ("relatedto".equals(codeString))
710          return ConceptMapEquivalence.RELATEDTO;
711        if ("equivalent".equals(codeString))
712          return ConceptMapEquivalence.EQUIVALENT;
713        if ("equal".equals(codeString))
714          return ConceptMapEquivalence.EQUAL;
715        if ("wider".equals(codeString))
716          return ConceptMapEquivalence.WIDER;
717        if ("subsumes".equals(codeString))
718          return ConceptMapEquivalence.SUBSUMES;
719        if ("narrower".equals(codeString))
720          return ConceptMapEquivalence.NARROWER;
721        if ("specializes".equals(codeString))
722          return ConceptMapEquivalence.SPECIALIZES;
723        if ("inexact".equals(codeString))
724          return ConceptMapEquivalence.INEXACT;
725        if ("unmatched".equals(codeString))
726          return ConceptMapEquivalence.UNMATCHED;
727        if ("disjoint".equals(codeString))
728          return ConceptMapEquivalence.DISJOINT;
729        throw new IllegalArgumentException("Unknown ConceptMapEquivalence code '"+codeString+"'");
730        }
731        public Enumeration<ConceptMapEquivalence> fromType(PrimitiveType<?> code) throws FHIRException {
732          if (code == null)
733            return null;
734          if (code.isEmpty())
735            return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.NULL, code);
736          String codeString = code.asStringValue();
737          if (codeString == null || "".equals(codeString))
738            return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.NULL, code);
739        if ("relatedto".equals(codeString))
740          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.RELATEDTO, code);
741        if ("equivalent".equals(codeString))
742          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.EQUIVALENT, code);
743        if ("equal".equals(codeString))
744          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.EQUAL, code);
745        if ("wider".equals(codeString))
746          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.WIDER, code);
747        if ("subsumes".equals(codeString))
748          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.SUBSUMES, code);
749        if ("narrower".equals(codeString))
750          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.NARROWER, code);
751        if ("specializes".equals(codeString))
752          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.SPECIALIZES, code);
753        if ("inexact".equals(codeString))
754          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.INEXACT, code);
755        if ("unmatched".equals(codeString))
756          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.UNMATCHED, code);
757        if ("disjoint".equals(codeString))
758          return new Enumeration<ConceptMapEquivalence>(this, ConceptMapEquivalence.DISJOINT, code);
759        throw new FHIRException("Unknown ConceptMapEquivalence code '"+codeString+"'");
760        }
761    public String toCode(ConceptMapEquivalence code) {
762      if (code == ConceptMapEquivalence.RELATEDTO)
763        return "relatedto";
764      if (code == ConceptMapEquivalence.EQUIVALENT)
765        return "equivalent";
766      if (code == ConceptMapEquivalence.EQUAL)
767        return "equal";
768      if (code == ConceptMapEquivalence.WIDER)
769        return "wider";
770      if (code == ConceptMapEquivalence.SUBSUMES)
771        return "subsumes";
772      if (code == ConceptMapEquivalence.NARROWER)
773        return "narrower";
774      if (code == ConceptMapEquivalence.SPECIALIZES)
775        return "specializes";
776      if (code == ConceptMapEquivalence.INEXACT)
777        return "inexact";
778      if (code == ConceptMapEquivalence.UNMATCHED)
779        return "unmatched";
780      if (code == ConceptMapEquivalence.DISJOINT)
781        return "disjoint";
782      return "?";
783      }
784    public String toSystem(ConceptMapEquivalence code) {
785      return code.getSystem();
786      }
787    }
788
789    public enum DataAbsentReason {
790        /**
791         * The value is expected to exist but is not known.
792         */
793        UNKNOWN, 
794        /**
795         * The source was asked but does not know the value.
796         */
797        ASKEDUNKNOWN, 
798        /**
799         * There is reason to expect (from the workflow) that the value may become known.
800         */
801        TEMPUNKNOWN, 
802        /**
803         * The workflow didn't lead to this value being known.
804         */
805        NOTASKED, 
806        /**
807         * The source was asked but declined to answer.
808         */
809        ASKEDDECLINED, 
810        /**
811         * The information is not available due to security, privacy or related reasons.
812         */
813        MASKED, 
814        /**
815         * There is no proper value for this element (e.g. last menstrual period for a male).
816         */
817        NOTAPPLICABLE, 
818        /**
819         * The source system wasn't capable of supporting this element.
820         */
821        UNSUPPORTED, 
822        /**
823         * The content of the data is represented in the resource narrative.
824         */
825        ASTEXT, 
826        /**
827         * Some system or workflow process error means that the information is not available.
828         */
829        ERROR, 
830        /**
831         * The numeric value is undefined or unrepresentable due to a floating point processing error.
832         */
833        NOTANUMBER, 
834        /**
835         * The numeric value is excessively low and unrepresentable due to a floating point processing error.
836         */
837        NEGATIVEINFINITY, 
838        /**
839         * The numeric value is excessively high and unrepresentable due to a floating point processing error.
840         */
841        POSITIVEINFINITY, 
842        /**
843         * The value is not available because the observation procedure (test, etc.) was not performed.
844         */
845        NOTPERFORMED, 
846        /**
847         * The value is not permitted in this context (e.g. due to profiles, or the base data types).
848         */
849        NOTPERMITTED, 
850        /**
851         * added to help the parsers
852         */
853        NULL;
854        public static DataAbsentReason fromCode(String codeString) throws FHIRException {
855            if (codeString == null || "".equals(codeString))
856                return null;
857        if ("unknown".equals(codeString))
858          return UNKNOWN;
859        if ("asked-unknown".equals(codeString))
860          return ASKEDUNKNOWN;
861        if ("temp-unknown".equals(codeString))
862          return TEMPUNKNOWN;
863        if ("not-asked".equals(codeString))
864          return NOTASKED;
865        if ("asked-declined".equals(codeString))
866          return ASKEDDECLINED;
867        if ("masked".equals(codeString))
868          return MASKED;
869        if ("not-applicable".equals(codeString))
870          return NOTAPPLICABLE;
871        if ("unsupported".equals(codeString))
872          return UNSUPPORTED;
873        if ("as-text".equals(codeString))
874          return ASTEXT;
875        if ("error".equals(codeString))
876          return ERROR;
877        if ("not-a-number".equals(codeString))
878          return NOTANUMBER;
879        if ("negative-infinity".equals(codeString))
880          return NEGATIVEINFINITY;
881        if ("positive-infinity".equals(codeString))
882          return POSITIVEINFINITY;
883        if ("not-performed".equals(codeString))
884          return NOTPERFORMED;
885        if ("not-permitted".equals(codeString))
886          return NOTPERMITTED;
887        throw new FHIRException("Unknown DataAbsentReason code '"+codeString+"'");
888        }
889        public String toCode() {
890          switch (this) {
891            case UNKNOWN: return "unknown";
892            case ASKEDUNKNOWN: return "asked-unknown";
893            case TEMPUNKNOWN: return "temp-unknown";
894            case NOTASKED: return "not-asked";
895            case ASKEDDECLINED: return "asked-declined";
896            case MASKED: return "masked";
897            case NOTAPPLICABLE: return "not-applicable";
898            case UNSUPPORTED: return "unsupported";
899            case ASTEXT: return "as-text";
900            case ERROR: return "error";
901            case NOTANUMBER: return "not-a-number";
902            case NEGATIVEINFINITY: return "negative-infinity";
903            case POSITIVEINFINITY: return "positive-infinity";
904            case NOTPERFORMED: return "not-performed";
905            case NOTPERMITTED: return "not-permitted";
906            case NULL: return null;
907            default: return "?";
908          }
909        }
910        public String getSystem() {
911          switch (this) {
912            case UNKNOWN: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
913            case ASKEDUNKNOWN: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
914            case TEMPUNKNOWN: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
915            case NOTASKED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
916            case ASKEDDECLINED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
917            case MASKED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
918            case NOTAPPLICABLE: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
919            case UNSUPPORTED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
920            case ASTEXT: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
921            case ERROR: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
922            case NOTANUMBER: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
923            case NEGATIVEINFINITY: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
924            case POSITIVEINFINITY: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
925            case NOTPERFORMED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
926            case NOTPERMITTED: return "http://terminology.hl7.org/CodeSystem/data-absent-reason";
927            case NULL: return null;
928            default: return "?";
929          }
930        }
931        public String getDefinition() {
932          switch (this) {
933            case UNKNOWN: return "The value is expected to exist but is not known.";
934            case ASKEDUNKNOWN: return "The source was asked but does not know the value.";
935            case TEMPUNKNOWN: return "There is reason to expect (from the workflow) that the value may become known.";
936            case NOTASKED: return "The workflow didn't lead to this value being known.";
937            case ASKEDDECLINED: return "The source was asked but declined to answer.";
938            case MASKED: return "The information is not available due to security, privacy or related reasons.";
939            case NOTAPPLICABLE: return "There is no proper value for this element (e.g. last menstrual period for a male).";
940            case UNSUPPORTED: return "The source system wasn't capable of supporting this element.";
941            case ASTEXT: return "The content of the data is represented in the resource narrative.";
942            case ERROR: return "Some system or workflow process error means that the information is not available.";
943            case NOTANUMBER: return "The numeric value is undefined or unrepresentable due to a floating point processing error.";
944            case NEGATIVEINFINITY: return "The numeric value is excessively low and unrepresentable due to a floating point processing error.";
945            case POSITIVEINFINITY: return "The numeric value is excessively high and unrepresentable due to a floating point processing error.";
946            case NOTPERFORMED: return "The value is not available because the observation procedure (test, etc.) was not performed.";
947            case NOTPERMITTED: return "The value is not permitted in this context (e.g. due to profiles, or the base data types).";
948            case NULL: return null;
949            default: return "?";
950          }
951        }
952        public String getDisplay() {
953          switch (this) {
954            case UNKNOWN: return "Unknown";
955            case ASKEDUNKNOWN: return "Asked But Unknown";
956            case TEMPUNKNOWN: return "Temporarily Unknown";
957            case NOTASKED: return "Not Asked";
958            case ASKEDDECLINED: return "Asked But Declined";
959            case MASKED: return "Masked";
960            case NOTAPPLICABLE: return "Not Applicable";
961            case UNSUPPORTED: return "Unsupported";
962            case ASTEXT: return "As Text";
963            case ERROR: return "Error";
964            case NOTANUMBER: return "Not a Number (NaN)";
965            case NEGATIVEINFINITY: return "Negative Infinity (NINF)";
966            case POSITIVEINFINITY: return "Positive Infinity (PINF)";
967            case NOTPERFORMED: return "Not Performed";
968            case NOTPERMITTED: return "Not Permitted";
969            case NULL: return null;
970            default: return "?";
971          }
972        }
973    }
974
975  public static class DataAbsentReasonEnumFactory implements EnumFactory<DataAbsentReason> {
976    public DataAbsentReason fromCode(String codeString) throws IllegalArgumentException {
977      if (codeString == null || "".equals(codeString))
978            if (codeString == null || "".equals(codeString))
979                return null;
980        if ("unknown".equals(codeString))
981          return DataAbsentReason.UNKNOWN;
982        if ("asked-unknown".equals(codeString))
983          return DataAbsentReason.ASKEDUNKNOWN;
984        if ("temp-unknown".equals(codeString))
985          return DataAbsentReason.TEMPUNKNOWN;
986        if ("not-asked".equals(codeString))
987          return DataAbsentReason.NOTASKED;
988        if ("asked-declined".equals(codeString))
989          return DataAbsentReason.ASKEDDECLINED;
990        if ("masked".equals(codeString))
991          return DataAbsentReason.MASKED;
992        if ("not-applicable".equals(codeString))
993          return DataAbsentReason.NOTAPPLICABLE;
994        if ("unsupported".equals(codeString))
995          return DataAbsentReason.UNSUPPORTED;
996        if ("as-text".equals(codeString))
997          return DataAbsentReason.ASTEXT;
998        if ("error".equals(codeString))
999          return DataAbsentReason.ERROR;
1000        if ("not-a-number".equals(codeString))
1001          return DataAbsentReason.NOTANUMBER;
1002        if ("negative-infinity".equals(codeString))
1003          return DataAbsentReason.NEGATIVEINFINITY;
1004        if ("positive-infinity".equals(codeString))
1005          return DataAbsentReason.POSITIVEINFINITY;
1006        if ("not-performed".equals(codeString))
1007          return DataAbsentReason.NOTPERFORMED;
1008        if ("not-permitted".equals(codeString))
1009          return DataAbsentReason.NOTPERMITTED;
1010        throw new IllegalArgumentException("Unknown DataAbsentReason code '"+codeString+"'");
1011        }
1012        public Enumeration<DataAbsentReason> fromType(PrimitiveType<?> code) throws FHIRException {
1013          if (code == null)
1014            return null;
1015          if (code.isEmpty())
1016            return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NULL, code);
1017          String codeString = code.asStringValue();
1018          if (codeString == null || "".equals(codeString))
1019            return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NULL, code);
1020        if ("unknown".equals(codeString))
1021          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.UNKNOWN, code);
1022        if ("asked-unknown".equals(codeString))
1023          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.ASKEDUNKNOWN, code);
1024        if ("temp-unknown".equals(codeString))
1025          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.TEMPUNKNOWN, code);
1026        if ("not-asked".equals(codeString))
1027          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NOTASKED, code);
1028        if ("asked-declined".equals(codeString))
1029          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.ASKEDDECLINED, code);
1030        if ("masked".equals(codeString))
1031          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.MASKED, code);
1032        if ("not-applicable".equals(codeString))
1033          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NOTAPPLICABLE, code);
1034        if ("unsupported".equals(codeString))
1035          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.UNSUPPORTED, code);
1036        if ("as-text".equals(codeString))
1037          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.ASTEXT, code);
1038        if ("error".equals(codeString))
1039          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.ERROR, code);
1040        if ("not-a-number".equals(codeString))
1041          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NOTANUMBER, code);
1042        if ("negative-infinity".equals(codeString))
1043          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NEGATIVEINFINITY, code);
1044        if ("positive-infinity".equals(codeString))
1045          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.POSITIVEINFINITY, code);
1046        if ("not-performed".equals(codeString))
1047          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NOTPERFORMED, code);
1048        if ("not-permitted".equals(codeString))
1049          return new Enumeration<DataAbsentReason>(this, DataAbsentReason.NOTPERMITTED, code);
1050        throw new FHIRException("Unknown DataAbsentReason code '"+codeString+"'");
1051        }
1052    public String toCode(DataAbsentReason code) {
1053      if (code == DataAbsentReason.UNKNOWN)
1054        return "unknown";
1055      if (code == DataAbsentReason.ASKEDUNKNOWN)
1056        return "asked-unknown";
1057      if (code == DataAbsentReason.TEMPUNKNOWN)
1058        return "temp-unknown";
1059      if (code == DataAbsentReason.NOTASKED)
1060        return "not-asked";
1061      if (code == DataAbsentReason.ASKEDDECLINED)
1062        return "asked-declined";
1063      if (code == DataAbsentReason.MASKED)
1064        return "masked";
1065      if (code == DataAbsentReason.NOTAPPLICABLE)
1066        return "not-applicable";
1067      if (code == DataAbsentReason.UNSUPPORTED)
1068        return "unsupported";
1069      if (code == DataAbsentReason.ASTEXT)
1070        return "as-text";
1071      if (code == DataAbsentReason.ERROR)
1072        return "error";
1073      if (code == DataAbsentReason.NOTANUMBER)
1074        return "not-a-number";
1075      if (code == DataAbsentReason.NEGATIVEINFINITY)
1076        return "negative-infinity";
1077      if (code == DataAbsentReason.POSITIVEINFINITY)
1078        return "positive-infinity";
1079      if (code == DataAbsentReason.NOTPERFORMED)
1080        return "not-performed";
1081      if (code == DataAbsentReason.NOTPERMITTED)
1082        return "not-permitted";
1083      return "?";
1084      }
1085    public String toSystem(DataAbsentReason code) {
1086      return code.getSystem();
1087      }
1088    }
1089
1090    public enum DataType {
1091        /**
1092         * An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.
1093         */
1094        ADDRESS, 
1095        /**
1096         * A duration of time during which an organism (or a process) has existed.
1097         */
1098        AGE, 
1099        /**
1100         * A  text note which also  contains information about who made the statement and when.
1101         */
1102        ANNOTATION, 
1103        /**
1104         * For referring to data content defined in other formats.
1105         */
1106        ATTACHMENT, 
1107        /**
1108         * Base definition for all elements that are defined inside a resource - but not those in a data type.
1109         */
1110        BACKBONEELEMENT, 
1111        /**
1112         * A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
1113         */
1114        CODEABLECONCEPT, 
1115        /**
1116         * A reference to a code defined by a terminology system.
1117         */
1118        CODING, 
1119        /**
1120         * Specifies contact information for a person or organization.
1121         */
1122        CONTACTDETAIL, 
1123        /**
1124         * Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
1125         */
1126        CONTACTPOINT, 
1127        /**
1128         * A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
1129         */
1130        CONTRIBUTOR, 
1131        /**
1132         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
1133         */
1134        COUNT, 
1135        /**
1136         * Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
1137         */
1138        DATAREQUIREMENT, 
1139        /**
1140         * A length - a value with a unit that is a physical distance.
1141         */
1142        DISTANCE, 
1143        /**
1144         * Indicates how the medication is/was taken or should be taken by the patient.
1145         */
1146        DOSAGE, 
1147        /**
1148         * A length of time.
1149         */
1150        DURATION, 
1151        /**
1152         * Base definition for all elements in a resource.
1153         */
1154        ELEMENT, 
1155        /**
1156         * Captures constraints on each element within the resource, profile, or extension.
1157         */
1158        ELEMENTDEFINITION, 
1159        /**
1160         * A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
1161         */
1162        EXPRESSION, 
1163        /**
1164         * Optional Extension Element - found in all resources.
1165         */
1166        EXTENSION, 
1167        /**
1168         * A human's name with the ability to identify parts and usage.
1169         */
1170        HUMANNAME, 
1171        /**
1172         * An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
1173         */
1174        IDENTIFIER, 
1175        /**
1176         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
1177         */
1178        MARKETINGSTATUS, 
1179        /**
1180         * The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
1181         */
1182        META, 
1183        /**
1184         * An amount of economic utility in some recognized currency.
1185         */
1186        MONEY, 
1187        /**
1188         * null
1189         */
1190        MONEYQUANTITY, 
1191        /**
1192         * A human-readable summary of the resource conveying the essential clinical and business information for the resource.
1193         */
1194        NARRATIVE, 
1195        /**
1196         * The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
1197         */
1198        PARAMETERDEFINITION, 
1199        /**
1200         * A time period defined by a start and end date and optionally time.
1201         */
1202        PERIOD, 
1203        /**
1204         * A populatioof people with some set of grouping criteria.
1205         */
1206        POPULATION, 
1207        /**
1208         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
1209         */
1210        PRODCHARACTERISTIC, 
1211        /**
1212         * The shelf-life and storage information for a medicinal product item or container can be described using this class.
1213         */
1214        PRODUCTSHELFLIFE, 
1215        /**
1216         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
1217         */
1218        QUANTITY, 
1219        /**
1220         * A set of ordered Quantities defined by a low and high limit.
1221         */
1222        RANGE, 
1223        /**
1224         * A relationship of two Quantity values - expressed as a numerator and a denominator.
1225         */
1226        RATIO, 
1227        /**
1228         * A reference from one resource to another.
1229         */
1230        REFERENCE, 
1231        /**
1232         * Related artifacts such as additional documentation, justification, or bibliographic references.
1233         */
1234        RELATEDARTIFACT, 
1235        /**
1236         * A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
1237         */
1238        SAMPLEDDATA, 
1239        /**
1240         * A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
1241         */
1242        SIGNATURE, 
1243        /**
1244         * null
1245         */
1246        SIMPLEQUANTITY, 
1247        /**
1248         * Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.
1249         */
1250        SUBSTANCEAMOUNT, 
1251        /**
1252         * Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
1253         */
1254        TIMING, 
1255        /**
1256         * A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
1257         */
1258        TRIGGERDEFINITION, 
1259        /**
1260         * Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
1261         */
1262        USAGECONTEXT, 
1263        /**
1264         * A stream of bytes
1265         */
1266        BASE64BINARY, 
1267        /**
1268         * Value of "true" or "false"
1269         */
1270        BOOLEAN, 
1271        /**
1272         * A URI that is a reference to a canonical URL on a FHIR resource
1273         */
1274        CANONICAL, 
1275        /**
1276         * A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
1277         */
1278        CODE, 
1279        /**
1280         * A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
1281         */
1282        DATE, 
1283        /**
1284         * A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.
1285         */
1286        DATETIME, 
1287        /**
1288         * A rational number with implicit precision
1289         */
1290        DECIMAL, 
1291        /**
1292         * Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.
1293         */
1294        ID, 
1295        /**
1296         * An instant in time - known at least to the second
1297         */
1298        INSTANT, 
1299        /**
1300         * A whole number
1301         */
1302        INTEGER, 
1303        /**
1304         * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
1305         */
1306        MARKDOWN, 
1307        /**
1308         * An OID represented as a URI
1309         */
1310        OID, 
1311        /**
1312         * An integer with a value that is positive (e.g. >0)
1313         */
1314        POSITIVEINT, 
1315        /**
1316         * A sequence of Unicode characters
1317         */
1318        STRING, 
1319        /**
1320         * A time during the day, with no date specified
1321         */
1322        TIME, 
1323        /**
1324         * An integer with a value that is not negative (e.g. >= 0)
1325         */
1326        UNSIGNEDINT, 
1327        /**
1328         * String of characters used to identify a name or a resource
1329         */
1330        URI, 
1331        /**
1332         * A URI that is a literal reference
1333         */
1334        URL, 
1335        /**
1336         * A UUID, represented as a URI
1337         */
1338        UUID, 
1339        /**
1340         * XHTML format, as defined by W3C, but restricted usage (mainly, no active content)
1341         */
1342        XHTML, 
1343        /**
1344         * added to help the parsers
1345         */
1346        NULL;
1347        public static DataType fromCode(String codeString) throws FHIRException {
1348            if (codeString == null || "".equals(codeString))
1349                return null;
1350        if ("Address".equals(codeString))
1351          return ADDRESS;
1352        if ("Age".equals(codeString))
1353          return AGE;
1354        if ("Annotation".equals(codeString))
1355          return ANNOTATION;
1356        if ("Attachment".equals(codeString))
1357          return ATTACHMENT;
1358        if ("BackboneElement".equals(codeString))
1359          return BACKBONEELEMENT;
1360        if ("CodeableConcept".equals(codeString))
1361          return CODEABLECONCEPT;
1362        if ("Coding".equals(codeString))
1363          return CODING;
1364        if ("ContactDetail".equals(codeString))
1365          return CONTACTDETAIL;
1366        if ("ContactPoint".equals(codeString))
1367          return CONTACTPOINT;
1368        if ("Contributor".equals(codeString))
1369          return CONTRIBUTOR;
1370        if ("Count".equals(codeString))
1371          return COUNT;
1372        if ("DataRequirement".equals(codeString))
1373          return DATAREQUIREMENT;
1374        if ("Distance".equals(codeString))
1375          return DISTANCE;
1376        if ("Dosage".equals(codeString))
1377          return DOSAGE;
1378        if ("Duration".equals(codeString))
1379          return DURATION;
1380        if ("Element".equals(codeString))
1381          return ELEMENT;
1382        if ("ElementDefinition".equals(codeString))
1383          return ELEMENTDEFINITION;
1384        if ("Expression".equals(codeString))
1385          return EXPRESSION;
1386        if ("Extension".equals(codeString))
1387          return EXTENSION;
1388        if ("HumanName".equals(codeString))
1389          return HUMANNAME;
1390        if ("Identifier".equals(codeString))
1391          return IDENTIFIER;
1392        if ("MarketingStatus".equals(codeString))
1393          return MARKETINGSTATUS;
1394        if ("Meta".equals(codeString))
1395          return META;
1396        if ("Money".equals(codeString))
1397          return MONEY;
1398        if ("MoneyQuantity".equals(codeString))
1399          return MONEYQUANTITY;
1400        if ("Narrative".equals(codeString))
1401          return NARRATIVE;
1402        if ("ParameterDefinition".equals(codeString))
1403          return PARAMETERDEFINITION;
1404        if ("Period".equals(codeString))
1405          return PERIOD;
1406        if ("Population".equals(codeString))
1407          return POPULATION;
1408        if ("ProdCharacteristic".equals(codeString))
1409          return PRODCHARACTERISTIC;
1410        if ("ProductShelfLife".equals(codeString))
1411          return PRODUCTSHELFLIFE;
1412        if ("Quantity".equals(codeString))
1413          return QUANTITY;
1414        if ("Range".equals(codeString))
1415          return RANGE;
1416        if ("Ratio".equals(codeString))
1417          return RATIO;
1418        if ("Reference".equals(codeString))
1419          return REFERENCE;
1420        if ("RelatedArtifact".equals(codeString))
1421          return RELATEDARTIFACT;
1422        if ("SampledData".equals(codeString))
1423          return SAMPLEDDATA;
1424        if ("Signature".equals(codeString))
1425          return SIGNATURE;
1426        if ("SimpleQuantity".equals(codeString))
1427          return SIMPLEQUANTITY;
1428        if ("SubstanceAmount".equals(codeString))
1429          return SUBSTANCEAMOUNT;
1430        if ("Timing".equals(codeString))
1431          return TIMING;
1432        if ("TriggerDefinition".equals(codeString))
1433          return TRIGGERDEFINITION;
1434        if ("UsageContext".equals(codeString))
1435          return USAGECONTEXT;
1436        if ("base64Binary".equals(codeString))
1437          return BASE64BINARY;
1438        if ("boolean".equals(codeString))
1439          return BOOLEAN;
1440        if ("canonical".equals(codeString))
1441          return CANONICAL;
1442        if ("code".equals(codeString))
1443          return CODE;
1444        if ("date".equals(codeString))
1445          return DATE;
1446        if ("dateTime".equals(codeString))
1447          return DATETIME;
1448        if ("decimal".equals(codeString))
1449          return DECIMAL;
1450        if ("id".equals(codeString))
1451          return ID;
1452        if ("instant".equals(codeString))
1453          return INSTANT;
1454        if ("integer".equals(codeString))
1455          return INTEGER;
1456        if ("markdown".equals(codeString))
1457          return MARKDOWN;
1458        if ("oid".equals(codeString))
1459          return OID;
1460        if ("positiveInt".equals(codeString))
1461          return POSITIVEINT;
1462        if ("string".equals(codeString))
1463          return STRING;
1464        if ("time".equals(codeString))
1465          return TIME;
1466        if ("unsignedInt".equals(codeString))
1467          return UNSIGNEDINT;
1468        if ("uri".equals(codeString))
1469          return URI;
1470        if ("url".equals(codeString))
1471          return URL;
1472        if ("uuid".equals(codeString))
1473          return UUID;
1474        if ("xhtml".equals(codeString))
1475          return XHTML;
1476        throw new FHIRException("Unknown DataType code '"+codeString+"'");
1477        }
1478        public String toCode() {
1479          switch (this) {
1480            case ADDRESS: return "Address";
1481            case AGE: return "Age";
1482            case ANNOTATION: return "Annotation";
1483            case ATTACHMENT: return "Attachment";
1484            case BACKBONEELEMENT: return "BackboneElement";
1485            case CODEABLECONCEPT: return "CodeableConcept";
1486            case CODING: return "Coding";
1487            case CONTACTDETAIL: return "ContactDetail";
1488            case CONTACTPOINT: return "ContactPoint";
1489            case CONTRIBUTOR: return "Contributor";
1490            case COUNT: return "Count";
1491            case DATAREQUIREMENT: return "DataRequirement";
1492            case DISTANCE: return "Distance";
1493            case DOSAGE: return "Dosage";
1494            case DURATION: return "Duration";
1495            case ELEMENT: return "Element";
1496            case ELEMENTDEFINITION: return "ElementDefinition";
1497            case EXPRESSION: return "Expression";
1498            case EXTENSION: return "Extension";
1499            case HUMANNAME: return "HumanName";
1500            case IDENTIFIER: return "Identifier";
1501            case MARKETINGSTATUS: return "MarketingStatus";
1502            case META: return "Meta";
1503            case MONEY: return "Money";
1504            case MONEYQUANTITY: return "MoneyQuantity";
1505            case NARRATIVE: return "Narrative";
1506            case PARAMETERDEFINITION: return "ParameterDefinition";
1507            case PERIOD: return "Period";
1508            case POPULATION: return "Population";
1509            case PRODCHARACTERISTIC: return "ProdCharacteristic";
1510            case PRODUCTSHELFLIFE: return "ProductShelfLife";
1511            case QUANTITY: return "Quantity";
1512            case RANGE: return "Range";
1513            case RATIO: return "Ratio";
1514            case REFERENCE: return "Reference";
1515            case RELATEDARTIFACT: return "RelatedArtifact";
1516            case SAMPLEDDATA: return "SampledData";
1517            case SIGNATURE: return "Signature";
1518            case SIMPLEQUANTITY: return "SimpleQuantity";
1519            case SUBSTANCEAMOUNT: return "SubstanceAmount";
1520            case TIMING: return "Timing";
1521            case TRIGGERDEFINITION: return "TriggerDefinition";
1522            case USAGECONTEXT: return "UsageContext";
1523            case BASE64BINARY: return "base64Binary";
1524            case BOOLEAN: return "boolean";
1525            case CANONICAL: return "canonical";
1526            case CODE: return "code";
1527            case DATE: return "date";
1528            case DATETIME: return "dateTime";
1529            case DECIMAL: return "decimal";
1530            case ID: return "id";
1531            case INSTANT: return "instant";
1532            case INTEGER: return "integer";
1533            case MARKDOWN: return "markdown";
1534            case OID: return "oid";
1535            case POSITIVEINT: return "positiveInt";
1536            case STRING: return "string";
1537            case TIME: return "time";
1538            case UNSIGNEDINT: return "unsignedInt";
1539            case URI: return "uri";
1540            case URL: return "url";
1541            case UUID: return "uuid";
1542            case XHTML: return "xhtml";
1543            case NULL: return null;
1544            default: return "?";
1545          }
1546        }
1547        public String getSystem() {
1548          switch (this) {
1549            case ADDRESS: return "http://hl7.org/fhir/data-types";
1550            case AGE: return "http://hl7.org/fhir/data-types";
1551            case ANNOTATION: return "http://hl7.org/fhir/data-types";
1552            case ATTACHMENT: return "http://hl7.org/fhir/data-types";
1553            case BACKBONEELEMENT: return "http://hl7.org/fhir/data-types";
1554            case CODEABLECONCEPT: return "http://hl7.org/fhir/data-types";
1555            case CODING: return "http://hl7.org/fhir/data-types";
1556            case CONTACTDETAIL: return "http://hl7.org/fhir/data-types";
1557            case CONTACTPOINT: return "http://hl7.org/fhir/data-types";
1558            case CONTRIBUTOR: return "http://hl7.org/fhir/data-types";
1559            case COUNT: return "http://hl7.org/fhir/data-types";
1560            case DATAREQUIREMENT: return "http://hl7.org/fhir/data-types";
1561            case DISTANCE: return "http://hl7.org/fhir/data-types";
1562            case DOSAGE: return "http://hl7.org/fhir/data-types";
1563            case DURATION: return "http://hl7.org/fhir/data-types";
1564            case ELEMENT: return "http://hl7.org/fhir/data-types";
1565            case ELEMENTDEFINITION: return "http://hl7.org/fhir/data-types";
1566            case EXPRESSION: return "http://hl7.org/fhir/data-types";
1567            case EXTENSION: return "http://hl7.org/fhir/data-types";
1568            case HUMANNAME: return "http://hl7.org/fhir/data-types";
1569            case IDENTIFIER: return "http://hl7.org/fhir/data-types";
1570            case MARKETINGSTATUS: return "http://hl7.org/fhir/data-types";
1571            case META: return "http://hl7.org/fhir/data-types";
1572            case MONEY: return "http://hl7.org/fhir/data-types";
1573            case MONEYQUANTITY: return "http://hl7.org/fhir/data-types";
1574            case NARRATIVE: return "http://hl7.org/fhir/data-types";
1575            case PARAMETERDEFINITION: return "http://hl7.org/fhir/data-types";
1576            case PERIOD: return "http://hl7.org/fhir/data-types";
1577            case POPULATION: return "http://hl7.org/fhir/data-types";
1578            case PRODCHARACTERISTIC: return "http://hl7.org/fhir/data-types";
1579            case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/data-types";
1580            case QUANTITY: return "http://hl7.org/fhir/data-types";
1581            case RANGE: return "http://hl7.org/fhir/data-types";
1582            case RATIO: return "http://hl7.org/fhir/data-types";
1583            case REFERENCE: return "http://hl7.org/fhir/data-types";
1584            case RELATEDARTIFACT: return "http://hl7.org/fhir/data-types";
1585            case SAMPLEDDATA: return "http://hl7.org/fhir/data-types";
1586            case SIGNATURE: return "http://hl7.org/fhir/data-types";
1587            case SIMPLEQUANTITY: return "http://hl7.org/fhir/data-types";
1588            case SUBSTANCEAMOUNT: return "http://hl7.org/fhir/data-types";
1589            case TIMING: return "http://hl7.org/fhir/data-types";
1590            case TRIGGERDEFINITION: return "http://hl7.org/fhir/data-types";
1591            case USAGECONTEXT: return "http://hl7.org/fhir/data-types";
1592            case BASE64BINARY: return "http://hl7.org/fhir/data-types";
1593            case BOOLEAN: return "http://hl7.org/fhir/data-types";
1594            case CANONICAL: return "http://hl7.org/fhir/data-types";
1595            case CODE: return "http://hl7.org/fhir/data-types";
1596            case DATE: return "http://hl7.org/fhir/data-types";
1597            case DATETIME: return "http://hl7.org/fhir/data-types";
1598            case DECIMAL: return "http://hl7.org/fhir/data-types";
1599            case ID: return "http://hl7.org/fhir/data-types";
1600            case INSTANT: return "http://hl7.org/fhir/data-types";
1601            case INTEGER: return "http://hl7.org/fhir/data-types";
1602            case MARKDOWN: return "http://hl7.org/fhir/data-types";
1603            case OID: return "http://hl7.org/fhir/data-types";
1604            case POSITIVEINT: return "http://hl7.org/fhir/data-types";
1605            case STRING: return "http://hl7.org/fhir/data-types";
1606            case TIME: return "http://hl7.org/fhir/data-types";
1607            case UNSIGNEDINT: return "http://hl7.org/fhir/data-types";
1608            case URI: return "http://hl7.org/fhir/data-types";
1609            case URL: return "http://hl7.org/fhir/data-types";
1610            case UUID: return "http://hl7.org/fhir/data-types";
1611            case XHTML: return "http://hl7.org/fhir/data-types";
1612            case NULL: return null;
1613            default: return "?";
1614          }
1615        }
1616        public String getDefinition() {
1617          switch (this) {
1618            case ADDRESS: return "An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.";
1619            case AGE: return "A duration of time during which an organism (or a process) has existed.";
1620            case ANNOTATION: return "A  text note which also  contains information about who made the statement and when.";
1621            case ATTACHMENT: return "For referring to data content defined in other formats.";
1622            case BACKBONEELEMENT: return "Base definition for all elements that are defined inside a resource - but not those in a data type.";
1623            case CODEABLECONCEPT: return "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.";
1624            case CODING: return "A reference to a code defined by a terminology system.";
1625            case CONTACTDETAIL: return "Specifies contact information for a person or organization.";
1626            case CONTACTPOINT: return "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.";
1627            case CONTRIBUTOR: return "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.";
1628            case COUNT: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
1629            case DATAREQUIREMENT: return "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.";
1630            case DISTANCE: return "A length - a value with a unit that is a physical distance.";
1631            case DOSAGE: return "Indicates how the medication is/was taken or should be taken by the patient.";
1632            case DURATION: return "A length of time.";
1633            case ELEMENT: return "Base definition for all elements in a resource.";
1634            case ELEMENTDEFINITION: return "Captures constraints on each element within the resource, profile, or extension.";
1635            case EXPRESSION: return "A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.";
1636            case EXTENSION: return "Optional Extension Element - found in all resources.";
1637            case HUMANNAME: return "A human's name with the ability to identify parts and usage.";
1638            case IDENTIFIER: return "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.";
1639            case MARKETINGSTATUS: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
1640            case META: return "The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.";
1641            case MONEY: return "An amount of economic utility in some recognized currency.";
1642            case MONEYQUANTITY: return "";
1643            case NARRATIVE: return "A human-readable summary of the resource conveying the essential clinical and business information for the resource.";
1644            case PARAMETERDEFINITION: return "The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.";
1645            case PERIOD: return "A time period defined by a start and end date and optionally time.";
1646            case POPULATION: return "A populatioof people with some set of grouping criteria.";
1647            case PRODCHARACTERISTIC: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
1648            case PRODUCTSHELFLIFE: return "The shelf-life and storage information for a medicinal product item or container can be described using this class.";
1649            case QUANTITY: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
1650            case RANGE: return "A set of ordered Quantities defined by a low and high limit.";
1651            case RATIO: return "A relationship of two Quantity values - expressed as a numerator and a denominator.";
1652            case REFERENCE: return "A reference from one resource to another.";
1653            case RELATEDARTIFACT: return "Related artifacts such as additional documentation, justification, or bibliographic references.";
1654            case SAMPLEDDATA: return "A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.";
1655            case SIGNATURE: return "A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.";
1656            case SIMPLEQUANTITY: return "";
1657            case SUBSTANCEAMOUNT: return "Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.";
1658            case TIMING: return "Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.";
1659            case TRIGGERDEFINITION: return "A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.";
1660            case USAGECONTEXT: return "Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).";
1661            case BASE64BINARY: return "A stream of bytes";
1662            case BOOLEAN: return "Value of \"true\" or \"false\"";
1663            case CANONICAL: return "A URI that is a reference to a canonical URL on a FHIR resource";
1664            case CODE: return "A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents";
1665            case DATE: return "A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.";
1666            case DATETIME: return "A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.";
1667            case DECIMAL: return "A rational number with implicit precision";
1668            case ID: return "Any combination of letters, numerals, \"-\" and \".\", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.";
1669            case INSTANT: return "An instant in time - known at least to the second";
1670            case INTEGER: return "A whole number";
1671            case MARKDOWN: return "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine";
1672            case OID: return "An OID represented as a URI";
1673            case POSITIVEINT: return "An integer with a value that is positive (e.g. >0)";
1674            case STRING: return "A sequence of Unicode characters";
1675            case TIME: return "A time during the day, with no date specified";
1676            case UNSIGNEDINT: return "An integer with a value that is not negative (e.g. >= 0)";
1677            case URI: return "String of characters used to identify a name or a resource";
1678            case URL: return "A URI that is a literal reference";
1679            case UUID: return "A UUID, represented as a URI";
1680            case XHTML: return "XHTML format, as defined by W3C, but restricted usage (mainly, no active content)";
1681            case NULL: return null;
1682            default: return "?";
1683          }
1684        }
1685        public String getDisplay() {
1686          switch (this) {
1687            case ADDRESS: return "Address";
1688            case AGE: return "Age";
1689            case ANNOTATION: return "Annotation";
1690            case ATTACHMENT: return "Attachment";
1691            case BACKBONEELEMENT: return "BackboneElement";
1692            case CODEABLECONCEPT: return "CodeableConcept";
1693            case CODING: return "Coding";
1694            case CONTACTDETAIL: return "ContactDetail";
1695            case CONTACTPOINT: return "ContactPoint";
1696            case CONTRIBUTOR: return "Contributor";
1697            case COUNT: return "Count";
1698            case DATAREQUIREMENT: return "DataRequirement";
1699            case DISTANCE: return "Distance";
1700            case DOSAGE: return "Dosage";
1701            case DURATION: return "Duration";
1702            case ELEMENT: return "Element";
1703            case ELEMENTDEFINITION: return "ElementDefinition";
1704            case EXPRESSION: return "Expression";
1705            case EXTENSION: return "Extension";
1706            case HUMANNAME: return "HumanName";
1707            case IDENTIFIER: return "Identifier";
1708            case MARKETINGSTATUS: return "MarketingStatus";
1709            case META: return "Meta";
1710            case MONEY: return "Money";
1711            case MONEYQUANTITY: return "MoneyQuantity";
1712            case NARRATIVE: return "Narrative";
1713            case PARAMETERDEFINITION: return "ParameterDefinition";
1714            case PERIOD: return "Period";
1715            case POPULATION: return "Population";
1716            case PRODCHARACTERISTIC: return "ProdCharacteristic";
1717            case PRODUCTSHELFLIFE: return "ProductShelfLife";
1718            case QUANTITY: return "Quantity";
1719            case RANGE: return "Range";
1720            case RATIO: return "Ratio";
1721            case REFERENCE: return "Reference";
1722            case RELATEDARTIFACT: return "RelatedArtifact";
1723            case SAMPLEDDATA: return "SampledData";
1724            case SIGNATURE: return "Signature";
1725            case SIMPLEQUANTITY: return "SimpleQuantity";
1726            case SUBSTANCEAMOUNT: return "SubstanceAmount";
1727            case TIMING: return "Timing";
1728            case TRIGGERDEFINITION: return "TriggerDefinition";
1729            case USAGECONTEXT: return "UsageContext";
1730            case BASE64BINARY: return "base64Binary";
1731            case BOOLEAN: return "boolean";
1732            case CANONICAL: return "canonical";
1733            case CODE: return "code";
1734            case DATE: return "date";
1735            case DATETIME: return "dateTime";
1736            case DECIMAL: return "decimal";
1737            case ID: return "id";
1738            case INSTANT: return "instant";
1739            case INTEGER: return "integer";
1740            case MARKDOWN: return "markdown";
1741            case OID: return "oid";
1742            case POSITIVEINT: return "positiveInt";
1743            case STRING: return "string";
1744            case TIME: return "time";
1745            case UNSIGNEDINT: return "unsignedInt";
1746            case URI: return "uri";
1747            case URL: return "url";
1748            case UUID: return "uuid";
1749            case XHTML: return "XHTML";
1750            case NULL: return null;
1751            default: return "?";
1752          }
1753        }
1754    }
1755
1756  public static class DataTypeEnumFactory implements EnumFactory<DataType> {
1757    public DataType fromCode(String codeString) throws IllegalArgumentException {
1758      if (codeString == null || "".equals(codeString))
1759            if (codeString == null || "".equals(codeString))
1760                return null;
1761        if ("Address".equals(codeString))
1762          return DataType.ADDRESS;
1763        if ("Age".equals(codeString))
1764          return DataType.AGE;
1765        if ("Annotation".equals(codeString))
1766          return DataType.ANNOTATION;
1767        if ("Attachment".equals(codeString))
1768          return DataType.ATTACHMENT;
1769        if ("BackboneElement".equals(codeString))
1770          return DataType.BACKBONEELEMENT;
1771        if ("CodeableConcept".equals(codeString))
1772          return DataType.CODEABLECONCEPT;
1773        if ("Coding".equals(codeString))
1774          return DataType.CODING;
1775        if ("ContactDetail".equals(codeString))
1776          return DataType.CONTACTDETAIL;
1777        if ("ContactPoint".equals(codeString))
1778          return DataType.CONTACTPOINT;
1779        if ("Contributor".equals(codeString))
1780          return DataType.CONTRIBUTOR;
1781        if ("Count".equals(codeString))
1782          return DataType.COUNT;
1783        if ("DataRequirement".equals(codeString))
1784          return DataType.DATAREQUIREMENT;
1785        if ("Distance".equals(codeString))
1786          return DataType.DISTANCE;
1787        if ("Dosage".equals(codeString))
1788          return DataType.DOSAGE;
1789        if ("Duration".equals(codeString))
1790          return DataType.DURATION;
1791        if ("Element".equals(codeString))
1792          return DataType.ELEMENT;
1793        if ("ElementDefinition".equals(codeString))
1794          return DataType.ELEMENTDEFINITION;
1795        if ("Expression".equals(codeString))
1796          return DataType.EXPRESSION;
1797        if ("Extension".equals(codeString))
1798          return DataType.EXTENSION;
1799        if ("HumanName".equals(codeString))
1800          return DataType.HUMANNAME;
1801        if ("Identifier".equals(codeString))
1802          return DataType.IDENTIFIER;
1803        if ("MarketingStatus".equals(codeString))
1804          return DataType.MARKETINGSTATUS;
1805        if ("Meta".equals(codeString))
1806          return DataType.META;
1807        if ("Money".equals(codeString))
1808          return DataType.MONEY;
1809        if ("MoneyQuantity".equals(codeString))
1810          return DataType.MONEYQUANTITY;
1811        if ("Narrative".equals(codeString))
1812          return DataType.NARRATIVE;
1813        if ("ParameterDefinition".equals(codeString))
1814          return DataType.PARAMETERDEFINITION;
1815        if ("Period".equals(codeString))
1816          return DataType.PERIOD;
1817        if ("Population".equals(codeString))
1818          return DataType.POPULATION;
1819        if ("ProdCharacteristic".equals(codeString))
1820          return DataType.PRODCHARACTERISTIC;
1821        if ("ProductShelfLife".equals(codeString))
1822          return DataType.PRODUCTSHELFLIFE;
1823        if ("Quantity".equals(codeString))
1824          return DataType.QUANTITY;
1825        if ("Range".equals(codeString))
1826          return DataType.RANGE;
1827        if ("Ratio".equals(codeString))
1828          return DataType.RATIO;
1829        if ("Reference".equals(codeString))
1830          return DataType.REFERENCE;
1831        if ("RelatedArtifact".equals(codeString))
1832          return DataType.RELATEDARTIFACT;
1833        if ("SampledData".equals(codeString))
1834          return DataType.SAMPLEDDATA;
1835        if ("Signature".equals(codeString))
1836          return DataType.SIGNATURE;
1837        if ("SimpleQuantity".equals(codeString))
1838          return DataType.SIMPLEQUANTITY;
1839        if ("SubstanceAmount".equals(codeString))
1840          return DataType.SUBSTANCEAMOUNT;
1841        if ("Timing".equals(codeString))
1842          return DataType.TIMING;
1843        if ("TriggerDefinition".equals(codeString))
1844          return DataType.TRIGGERDEFINITION;
1845        if ("UsageContext".equals(codeString))
1846          return DataType.USAGECONTEXT;
1847        if ("base64Binary".equals(codeString))
1848          return DataType.BASE64BINARY;
1849        if ("boolean".equals(codeString))
1850          return DataType.BOOLEAN;
1851        if ("canonical".equals(codeString))
1852          return DataType.CANONICAL;
1853        if ("code".equals(codeString))
1854          return DataType.CODE;
1855        if ("date".equals(codeString))
1856          return DataType.DATE;
1857        if ("dateTime".equals(codeString))
1858          return DataType.DATETIME;
1859        if ("decimal".equals(codeString))
1860          return DataType.DECIMAL;
1861        if ("id".equals(codeString))
1862          return DataType.ID;
1863        if ("instant".equals(codeString))
1864          return DataType.INSTANT;
1865        if ("integer".equals(codeString))
1866          return DataType.INTEGER;
1867        if ("markdown".equals(codeString))
1868          return DataType.MARKDOWN;
1869        if ("oid".equals(codeString))
1870          return DataType.OID;
1871        if ("positiveInt".equals(codeString))
1872          return DataType.POSITIVEINT;
1873        if ("string".equals(codeString))
1874          return DataType.STRING;
1875        if ("time".equals(codeString))
1876          return DataType.TIME;
1877        if ("unsignedInt".equals(codeString))
1878          return DataType.UNSIGNEDINT;
1879        if ("uri".equals(codeString))
1880          return DataType.URI;
1881        if ("url".equals(codeString))
1882          return DataType.URL;
1883        if ("uuid".equals(codeString))
1884          return DataType.UUID;
1885        if ("xhtml".equals(codeString))
1886          return DataType.XHTML;
1887        throw new IllegalArgumentException("Unknown DataType code '"+codeString+"'");
1888        }
1889        public Enumeration<DataType> fromType(PrimitiveType<?> code) throws FHIRException {
1890          if (code == null)
1891            return null;
1892          if (code.isEmpty())
1893            return new Enumeration<DataType>(this, DataType.NULL, code);
1894          String codeString = code.asStringValue();
1895          if (codeString == null || "".equals(codeString))
1896            return new Enumeration<DataType>(this, DataType.NULL, code);
1897        if ("Address".equals(codeString))
1898          return new Enumeration<DataType>(this, DataType.ADDRESS, code);
1899        if ("Age".equals(codeString))
1900          return new Enumeration<DataType>(this, DataType.AGE, code);
1901        if ("Annotation".equals(codeString))
1902          return new Enumeration<DataType>(this, DataType.ANNOTATION, code);
1903        if ("Attachment".equals(codeString))
1904          return new Enumeration<DataType>(this, DataType.ATTACHMENT, code);
1905        if ("BackboneElement".equals(codeString))
1906          return new Enumeration<DataType>(this, DataType.BACKBONEELEMENT, code);
1907        if ("CodeableConcept".equals(codeString))
1908          return new Enumeration<DataType>(this, DataType.CODEABLECONCEPT, code);
1909        if ("Coding".equals(codeString))
1910          return new Enumeration<DataType>(this, DataType.CODING, code);
1911        if ("ContactDetail".equals(codeString))
1912          return new Enumeration<DataType>(this, DataType.CONTACTDETAIL, code);
1913        if ("ContactPoint".equals(codeString))
1914          return new Enumeration<DataType>(this, DataType.CONTACTPOINT, code);
1915        if ("Contributor".equals(codeString))
1916          return new Enumeration<DataType>(this, DataType.CONTRIBUTOR, code);
1917        if ("Count".equals(codeString))
1918          return new Enumeration<DataType>(this, DataType.COUNT, code);
1919        if ("DataRequirement".equals(codeString))
1920          return new Enumeration<DataType>(this, DataType.DATAREQUIREMENT, code);
1921        if ("Distance".equals(codeString))
1922          return new Enumeration<DataType>(this, DataType.DISTANCE, code);
1923        if ("Dosage".equals(codeString))
1924          return new Enumeration<DataType>(this, DataType.DOSAGE, code);
1925        if ("Duration".equals(codeString))
1926          return new Enumeration<DataType>(this, DataType.DURATION, code);
1927        if ("Element".equals(codeString))
1928          return new Enumeration<DataType>(this, DataType.ELEMENT, code);
1929        if ("ElementDefinition".equals(codeString))
1930          return new Enumeration<DataType>(this, DataType.ELEMENTDEFINITION, code);
1931        if ("Expression".equals(codeString))
1932          return new Enumeration<DataType>(this, DataType.EXPRESSION, code);
1933        if ("Extension".equals(codeString))
1934          return new Enumeration<DataType>(this, DataType.EXTENSION, code);
1935        if ("HumanName".equals(codeString))
1936          return new Enumeration<DataType>(this, DataType.HUMANNAME, code);
1937        if ("Identifier".equals(codeString))
1938          return new Enumeration<DataType>(this, DataType.IDENTIFIER, code);
1939        if ("MarketingStatus".equals(codeString))
1940          return new Enumeration<DataType>(this, DataType.MARKETINGSTATUS, code);
1941        if ("Meta".equals(codeString))
1942          return new Enumeration<DataType>(this, DataType.META, code);
1943        if ("Money".equals(codeString))
1944          return new Enumeration<DataType>(this, DataType.MONEY, code);
1945        if ("MoneyQuantity".equals(codeString))
1946          return new Enumeration<DataType>(this, DataType.MONEYQUANTITY, code);
1947        if ("Narrative".equals(codeString))
1948          return new Enumeration<DataType>(this, DataType.NARRATIVE, code);
1949        if ("ParameterDefinition".equals(codeString))
1950          return new Enumeration<DataType>(this, DataType.PARAMETERDEFINITION, code);
1951        if ("Period".equals(codeString))
1952          return new Enumeration<DataType>(this, DataType.PERIOD, code);
1953        if ("Population".equals(codeString))
1954          return new Enumeration<DataType>(this, DataType.POPULATION, code);
1955        if ("ProdCharacteristic".equals(codeString))
1956          return new Enumeration<DataType>(this, DataType.PRODCHARACTERISTIC, code);
1957        if ("ProductShelfLife".equals(codeString))
1958          return new Enumeration<DataType>(this, DataType.PRODUCTSHELFLIFE, code);
1959        if ("Quantity".equals(codeString))
1960          return new Enumeration<DataType>(this, DataType.QUANTITY, code);
1961        if ("Range".equals(codeString))
1962          return new Enumeration<DataType>(this, DataType.RANGE, code);
1963        if ("Ratio".equals(codeString))
1964          return new Enumeration<DataType>(this, DataType.RATIO, code);
1965        if ("Reference".equals(codeString))
1966          return new Enumeration<DataType>(this, DataType.REFERENCE, code);
1967        if ("RelatedArtifact".equals(codeString))
1968          return new Enumeration<DataType>(this, DataType.RELATEDARTIFACT, code);
1969        if ("SampledData".equals(codeString))
1970          return new Enumeration<DataType>(this, DataType.SAMPLEDDATA, code);
1971        if ("Signature".equals(codeString))
1972          return new Enumeration<DataType>(this, DataType.SIGNATURE, code);
1973        if ("SimpleQuantity".equals(codeString))
1974          return new Enumeration<DataType>(this, DataType.SIMPLEQUANTITY, code);
1975        if ("SubstanceAmount".equals(codeString))
1976          return new Enumeration<DataType>(this, DataType.SUBSTANCEAMOUNT, code);
1977        if ("Timing".equals(codeString))
1978          return new Enumeration<DataType>(this, DataType.TIMING, code);
1979        if ("TriggerDefinition".equals(codeString))
1980          return new Enumeration<DataType>(this, DataType.TRIGGERDEFINITION, code);
1981        if ("UsageContext".equals(codeString))
1982          return new Enumeration<DataType>(this, DataType.USAGECONTEXT, code);
1983        if ("base64Binary".equals(codeString))
1984          return new Enumeration<DataType>(this, DataType.BASE64BINARY, code);
1985        if ("boolean".equals(codeString))
1986          return new Enumeration<DataType>(this, DataType.BOOLEAN, code);
1987        if ("canonical".equals(codeString))
1988          return new Enumeration<DataType>(this, DataType.CANONICAL, code);
1989        if ("code".equals(codeString))
1990          return new Enumeration<DataType>(this, DataType.CODE, code);
1991        if ("date".equals(codeString))
1992          return new Enumeration<DataType>(this, DataType.DATE, code);
1993        if ("dateTime".equals(codeString))
1994          return new Enumeration<DataType>(this, DataType.DATETIME, code);
1995        if ("decimal".equals(codeString))
1996          return new Enumeration<DataType>(this, DataType.DECIMAL, code);
1997        if ("id".equals(codeString))
1998          return new Enumeration<DataType>(this, DataType.ID, code);
1999        if ("instant".equals(codeString))
2000          return new Enumeration<DataType>(this, DataType.INSTANT, code);
2001        if ("integer".equals(codeString))
2002          return new Enumeration<DataType>(this, DataType.INTEGER, code);
2003        if ("markdown".equals(codeString))
2004          return new Enumeration<DataType>(this, DataType.MARKDOWN, code);
2005        if ("oid".equals(codeString))
2006          return new Enumeration<DataType>(this, DataType.OID, code);
2007        if ("positiveInt".equals(codeString))
2008          return new Enumeration<DataType>(this, DataType.POSITIVEINT, code);
2009        if ("string".equals(codeString))
2010          return new Enumeration<DataType>(this, DataType.STRING, code);
2011        if ("time".equals(codeString))
2012          return new Enumeration<DataType>(this, DataType.TIME, code);
2013        if ("unsignedInt".equals(codeString))
2014          return new Enumeration<DataType>(this, DataType.UNSIGNEDINT, code);
2015        if ("uri".equals(codeString))
2016          return new Enumeration<DataType>(this, DataType.URI, code);
2017        if ("url".equals(codeString))
2018          return new Enumeration<DataType>(this, DataType.URL, code);
2019        if ("uuid".equals(codeString))
2020          return new Enumeration<DataType>(this, DataType.UUID, code);
2021        if ("xhtml".equals(codeString))
2022          return new Enumeration<DataType>(this, DataType.XHTML, code);
2023        throw new FHIRException("Unknown DataType code '"+codeString+"'");
2024        }
2025    public String toCode(DataType code) {
2026      if (code == DataType.ADDRESS)
2027        return "Address";
2028      if (code == DataType.AGE)
2029        return "Age";
2030      if (code == DataType.ANNOTATION)
2031        return "Annotation";
2032      if (code == DataType.ATTACHMENT)
2033        return "Attachment";
2034      if (code == DataType.BACKBONEELEMENT)
2035        return "BackboneElement";
2036      if (code == DataType.CODEABLECONCEPT)
2037        return "CodeableConcept";
2038      if (code == DataType.CODING)
2039        return "Coding";
2040      if (code == DataType.CONTACTDETAIL)
2041        return "ContactDetail";
2042      if (code == DataType.CONTACTPOINT)
2043        return "ContactPoint";
2044      if (code == DataType.CONTRIBUTOR)
2045        return "Contributor";
2046      if (code == DataType.COUNT)
2047        return "Count";
2048      if (code == DataType.DATAREQUIREMENT)
2049        return "DataRequirement";
2050      if (code == DataType.DISTANCE)
2051        return "Distance";
2052      if (code == DataType.DOSAGE)
2053        return "Dosage";
2054      if (code == DataType.DURATION)
2055        return "Duration";
2056      if (code == DataType.ELEMENT)
2057        return "Element";
2058      if (code == DataType.ELEMENTDEFINITION)
2059        return "ElementDefinition";
2060      if (code == DataType.EXPRESSION)
2061        return "Expression";
2062      if (code == DataType.EXTENSION)
2063        return "Extension";
2064      if (code == DataType.HUMANNAME)
2065        return "HumanName";
2066      if (code == DataType.IDENTIFIER)
2067        return "Identifier";
2068      if (code == DataType.MARKETINGSTATUS)
2069        return "MarketingStatus";
2070      if (code == DataType.META)
2071        return "Meta";
2072      if (code == DataType.MONEY)
2073        return "Money";
2074      if (code == DataType.MONEYQUANTITY)
2075        return "MoneyQuantity";
2076      if (code == DataType.NARRATIVE)
2077        return "Narrative";
2078      if (code == DataType.PARAMETERDEFINITION)
2079        return "ParameterDefinition";
2080      if (code == DataType.PERIOD)
2081        return "Period";
2082      if (code == DataType.POPULATION)
2083        return "Population";
2084      if (code == DataType.PRODCHARACTERISTIC)
2085        return "ProdCharacteristic";
2086      if (code == DataType.PRODUCTSHELFLIFE)
2087        return "ProductShelfLife";
2088      if (code == DataType.QUANTITY)
2089        return "Quantity";
2090      if (code == DataType.RANGE)
2091        return "Range";
2092      if (code == DataType.RATIO)
2093        return "Ratio";
2094      if (code == DataType.REFERENCE)
2095        return "Reference";
2096      if (code == DataType.RELATEDARTIFACT)
2097        return "RelatedArtifact";
2098      if (code == DataType.SAMPLEDDATA)
2099        return "SampledData";
2100      if (code == DataType.SIGNATURE)
2101        return "Signature";
2102      if (code == DataType.SIMPLEQUANTITY)
2103        return "SimpleQuantity";
2104      if (code == DataType.SUBSTANCEAMOUNT)
2105        return "SubstanceAmount";
2106      if (code == DataType.TIMING)
2107        return "Timing";
2108      if (code == DataType.TRIGGERDEFINITION)
2109        return "TriggerDefinition";
2110      if (code == DataType.USAGECONTEXT)
2111        return "UsageContext";
2112      if (code == DataType.BASE64BINARY)
2113        return "base64Binary";
2114      if (code == DataType.BOOLEAN)
2115        return "boolean";
2116      if (code == DataType.CANONICAL)
2117        return "canonical";
2118      if (code == DataType.CODE)
2119        return "code";
2120      if (code == DataType.DATE)
2121        return "date";
2122      if (code == DataType.DATETIME)
2123        return "dateTime";
2124      if (code == DataType.DECIMAL)
2125        return "decimal";
2126      if (code == DataType.ID)
2127        return "id";
2128      if (code == DataType.INSTANT)
2129        return "instant";
2130      if (code == DataType.INTEGER)
2131        return "integer";
2132      if (code == DataType.MARKDOWN)
2133        return "markdown";
2134      if (code == DataType.OID)
2135        return "oid";
2136      if (code == DataType.POSITIVEINT)
2137        return "positiveInt";
2138      if (code == DataType.STRING)
2139        return "string";
2140      if (code == DataType.TIME)
2141        return "time";
2142      if (code == DataType.UNSIGNEDINT)
2143        return "unsignedInt";
2144      if (code == DataType.URI)
2145        return "uri";
2146      if (code == DataType.URL)
2147        return "url";
2148      if (code == DataType.UUID)
2149        return "uuid";
2150      if (code == DataType.XHTML)
2151        return "xhtml";
2152      return "?";
2153      }
2154    public String toSystem(DataType code) {
2155      return code.getSystem();
2156      }
2157    }
2158
2159    public enum DefinitionResourceType {
2160        /**
2161         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
2162         */
2163        ACTIVITYDEFINITION, 
2164        /**
2165         * The EventDefinition resource provides a reusable description of when a particular event can occur.
2166         */
2167        EVENTDEFINITION, 
2168        /**
2169         * The Measure resource provides the definition of a quality measure.
2170         */
2171        MEASURE, 
2172        /**
2173         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
2174         */
2175        OPERATIONDEFINITION, 
2176        /**
2177         * This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.
2178         */
2179        PLANDEFINITION, 
2180        /**
2181         * A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.
2182         */
2183        QUESTIONNAIRE, 
2184        /**
2185         * added to help the parsers
2186         */
2187        NULL;
2188        public static DefinitionResourceType fromCode(String codeString) throws FHIRException {
2189            if (codeString == null || "".equals(codeString))
2190                return null;
2191        if ("ActivityDefinition".equals(codeString))
2192          return ACTIVITYDEFINITION;
2193        if ("EventDefinition".equals(codeString))
2194          return EVENTDEFINITION;
2195        if ("Measure".equals(codeString))
2196          return MEASURE;
2197        if ("OperationDefinition".equals(codeString))
2198          return OPERATIONDEFINITION;
2199        if ("PlanDefinition".equals(codeString))
2200          return PLANDEFINITION;
2201        if ("Questionnaire".equals(codeString))
2202          return QUESTIONNAIRE;
2203        throw new FHIRException("Unknown DefinitionResourceType code '"+codeString+"'");
2204        }
2205        public String toCode() {
2206          switch (this) {
2207            case ACTIVITYDEFINITION: return "ActivityDefinition";
2208            case EVENTDEFINITION: return "EventDefinition";
2209            case MEASURE: return "Measure";
2210            case OPERATIONDEFINITION: return "OperationDefinition";
2211            case PLANDEFINITION: return "PlanDefinition";
2212            case QUESTIONNAIRE: return "Questionnaire";
2213            case NULL: return null;
2214            default: return "?";
2215          }
2216        }
2217        public String getSystem() {
2218          switch (this) {
2219            case ACTIVITYDEFINITION: return "http://hl7.org/fhir/definition-resource-types";
2220            case EVENTDEFINITION: return "http://hl7.org/fhir/definition-resource-types";
2221            case MEASURE: return "http://hl7.org/fhir/definition-resource-types";
2222            case OPERATIONDEFINITION: return "http://hl7.org/fhir/definition-resource-types";
2223            case PLANDEFINITION: return "http://hl7.org/fhir/definition-resource-types";
2224            case QUESTIONNAIRE: return "http://hl7.org/fhir/definition-resource-types";
2225            case NULL: return null;
2226            default: return "?";
2227          }
2228        }
2229        public String getDefinition() {
2230          switch (this) {
2231            case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.";
2232            case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur.";
2233            case MEASURE: return "The Measure resource provides the definition of a quality measure.";
2234            case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).";
2235            case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.";
2236            case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.";
2237            case NULL: return null;
2238            default: return "?";
2239          }
2240        }
2241        public String getDisplay() {
2242          switch (this) {
2243            case ACTIVITYDEFINITION: return "ActivityDefinition";
2244            case EVENTDEFINITION: return "EventDefinition";
2245            case MEASURE: return "Measure";
2246            case OPERATIONDEFINITION: return "OperationDefinition";
2247            case PLANDEFINITION: return "PlanDefinition";
2248            case QUESTIONNAIRE: return "Questionnaire";
2249            case NULL: return null;
2250            default: return "?";
2251          }
2252        }
2253    }
2254
2255  public static class DefinitionResourceTypeEnumFactory implements EnumFactory<DefinitionResourceType> {
2256    public DefinitionResourceType fromCode(String codeString) throws IllegalArgumentException {
2257      if (codeString == null || "".equals(codeString))
2258            if (codeString == null || "".equals(codeString))
2259                return null;
2260        if ("ActivityDefinition".equals(codeString))
2261          return DefinitionResourceType.ACTIVITYDEFINITION;
2262        if ("EventDefinition".equals(codeString))
2263          return DefinitionResourceType.EVENTDEFINITION;
2264        if ("Measure".equals(codeString))
2265          return DefinitionResourceType.MEASURE;
2266        if ("OperationDefinition".equals(codeString))
2267          return DefinitionResourceType.OPERATIONDEFINITION;
2268        if ("PlanDefinition".equals(codeString))
2269          return DefinitionResourceType.PLANDEFINITION;
2270        if ("Questionnaire".equals(codeString))
2271          return DefinitionResourceType.QUESTIONNAIRE;
2272        throw new IllegalArgumentException("Unknown DefinitionResourceType code '"+codeString+"'");
2273        }
2274        public Enumeration<DefinitionResourceType> fromType(PrimitiveType<?> code) throws FHIRException {
2275          if (code == null)
2276            return null;
2277          if (code.isEmpty())
2278            return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.NULL, code);
2279          String codeString = code.asStringValue();
2280          if (codeString == null || "".equals(codeString))
2281            return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.NULL, code);
2282        if ("ActivityDefinition".equals(codeString))
2283          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.ACTIVITYDEFINITION, code);
2284        if ("EventDefinition".equals(codeString))
2285          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.EVENTDEFINITION, code);
2286        if ("Measure".equals(codeString))
2287          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.MEASURE, code);
2288        if ("OperationDefinition".equals(codeString))
2289          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.OPERATIONDEFINITION, code);
2290        if ("PlanDefinition".equals(codeString))
2291          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.PLANDEFINITION, code);
2292        if ("Questionnaire".equals(codeString))
2293          return new Enumeration<DefinitionResourceType>(this, DefinitionResourceType.QUESTIONNAIRE, code);
2294        throw new FHIRException("Unknown DefinitionResourceType code '"+codeString+"'");
2295        }
2296    public String toCode(DefinitionResourceType code) {
2297      if (code == DefinitionResourceType.ACTIVITYDEFINITION)
2298        return "ActivityDefinition";
2299      if (code == DefinitionResourceType.EVENTDEFINITION)
2300        return "EventDefinition";
2301      if (code == DefinitionResourceType.MEASURE)
2302        return "Measure";
2303      if (code == DefinitionResourceType.OPERATIONDEFINITION)
2304        return "OperationDefinition";
2305      if (code == DefinitionResourceType.PLANDEFINITION)
2306        return "PlanDefinition";
2307      if (code == DefinitionResourceType.QUESTIONNAIRE)
2308        return "Questionnaire";
2309      return "?";
2310      }
2311    public String toSystem(DefinitionResourceType code) {
2312      return code.getSystem();
2313      }
2314    }
2315
2316    public enum DocumentReferenceStatus {
2317        /**
2318         * This is the current reference for this document.
2319         */
2320        CURRENT, 
2321        /**
2322         * This reference has been superseded by another reference.
2323         */
2324        SUPERSEDED, 
2325        /**
2326         * This reference was created in error.
2327         */
2328        ENTEREDINERROR, 
2329        /**
2330         * added to help the parsers
2331         */
2332        NULL;
2333        public static DocumentReferenceStatus fromCode(String codeString) throws FHIRException {
2334            if (codeString == null || "".equals(codeString))
2335                return null;
2336        if ("current".equals(codeString))
2337          return CURRENT;
2338        if ("superseded".equals(codeString))
2339          return SUPERSEDED;
2340        if ("entered-in-error".equals(codeString))
2341          return ENTEREDINERROR;
2342        throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2343        }
2344        public String toCode() {
2345          switch (this) {
2346            case CURRENT: return "current";
2347            case SUPERSEDED: return "superseded";
2348            case ENTEREDINERROR: return "entered-in-error";
2349            case NULL: return null;
2350            default: return "?";
2351          }
2352        }
2353        public String getSystem() {
2354          switch (this) {
2355            case CURRENT: return "http://hl7.org/fhir/document-reference-status";
2356            case SUPERSEDED: return "http://hl7.org/fhir/document-reference-status";
2357            case ENTEREDINERROR: return "http://hl7.org/fhir/document-reference-status";
2358            case NULL: return null;
2359            default: return "?";
2360          }
2361        }
2362        public String getDefinition() {
2363          switch (this) {
2364            case CURRENT: return "This is the current reference for this document.";
2365            case SUPERSEDED: return "This reference has been superseded by another reference.";
2366            case ENTEREDINERROR: return "This reference was created in error.";
2367            case NULL: return null;
2368            default: return "?";
2369          }
2370        }
2371        public String getDisplay() {
2372          switch (this) {
2373            case CURRENT: return "Current";
2374            case SUPERSEDED: return "Superseded";
2375            case ENTEREDINERROR: return "Entered in Error";
2376            case NULL: return null;
2377            default: return "?";
2378          }
2379        }
2380    }
2381
2382  public static class DocumentReferenceStatusEnumFactory implements EnumFactory<DocumentReferenceStatus> {
2383    public DocumentReferenceStatus fromCode(String codeString) throws IllegalArgumentException {
2384      if (codeString == null || "".equals(codeString))
2385            if (codeString == null || "".equals(codeString))
2386                return null;
2387        if ("current".equals(codeString))
2388          return DocumentReferenceStatus.CURRENT;
2389        if ("superseded".equals(codeString))
2390          return DocumentReferenceStatus.SUPERSEDED;
2391        if ("entered-in-error".equals(codeString))
2392          return DocumentReferenceStatus.ENTEREDINERROR;
2393        throw new IllegalArgumentException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2394        }
2395        public Enumeration<DocumentReferenceStatus> fromType(PrimitiveType<?> code) throws FHIRException {
2396          if (code == null)
2397            return null;
2398          if (code.isEmpty())
2399            return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.NULL, code);
2400          String codeString = code.asStringValue();
2401          if (codeString == null || "".equals(codeString))
2402            return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.NULL, code);
2403        if ("current".equals(codeString))
2404          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.CURRENT, code);
2405        if ("superseded".equals(codeString))
2406          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.SUPERSEDED, code);
2407        if ("entered-in-error".equals(codeString))
2408          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.ENTEREDINERROR, code);
2409        throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2410        }
2411    public String toCode(DocumentReferenceStatus code) {
2412      if (code == DocumentReferenceStatus.CURRENT)
2413        return "current";
2414      if (code == DocumentReferenceStatus.SUPERSEDED)
2415        return "superseded";
2416      if (code == DocumentReferenceStatus.ENTEREDINERROR)
2417        return "entered-in-error";
2418      return "?";
2419      }
2420    public String toSystem(DocumentReferenceStatus code) {
2421      return code.getSystem();
2422      }
2423    }
2424
2425    public enum EventResourceType {
2426        /**
2427         * Item containing charge code(s) associated with the provision of healthcare provider products.
2428         */
2429        CHARGEITEM, 
2430        /**
2431         * Remittance resource.
2432         */
2433        CLAIMRESPONSE, 
2434        /**
2435         * A clinical assessment performed when planning treatments and management strategies for a patient.
2436         */
2437        CLINICALIMPRESSION, 
2438        /**
2439         * A record of information transmitted from a sender to a receiver.
2440         */
2441        COMMUNICATION, 
2442        /**
2443         * A set of resources composed into a single coherent clinical statement with clinical attestation.
2444         */
2445        COMPOSITION, 
2446        /**
2447         * Detailed information about conditions, problems or diagnoses.
2448         */
2449        CONDITION, 
2450        /**
2451         * A healthcare consumer's policy choices to permits or denies recipients or roles to perform actions for specific purposes and periods of time.
2452         */
2453        CONSENT, 
2454        /**
2455         * Insurance or medical plan or a payment agreement.
2456         */
2457        COVERAGE, 
2458        /**
2459         * Record of use of a device.
2460         */
2461        DEVICEUSESTATEMENT, 
2462        /**
2463         * A Diagnostic report - a combination of request information, atomic results, images, interpretation, as well as formatted reports.
2464         */
2465        DIAGNOSTICREPORT, 
2466        /**
2467         * A list that defines a set of documents.
2468         */
2469        DOCUMENTMANIFEST, 
2470        /**
2471         * A reference to a document.
2472         */
2473        DOCUMENTREFERENCE, 
2474        /**
2475         * An interaction during which services are provided to the patient.
2476         */
2477        ENCOUNTER, 
2478        /**
2479         * EnrollmentResponse resource.
2480         */
2481        ENROLLMENTRESPONSE, 
2482        /**
2483         * An association of a Patient with an Organization and  Healthcare Provider(s) for a period of time that the Organization assumes some level of responsibility.
2484         */
2485        EPISODEOFCARE, 
2486        /**
2487         * Explanation of Benefit resource.
2488         */
2489        EXPLANATIONOFBENEFIT, 
2490        /**
2491         * Information about patient's relatives, relevant for patient.
2492         */
2493        FAMILYMEMBERHISTORY, 
2494        /**
2495         * The formal response to a guidance request.
2496         */
2497        GUIDANCERESPONSE, 
2498        /**
2499         * A set of images produced in single study (one or more series of references images).
2500         */
2501        IMAGINGSTUDY, 
2502        /**
2503         * Immunization event information.
2504         */
2505        IMMUNIZATION, 
2506        /**
2507         * Results of a measure evaluation.
2508         */
2509        MEASUREREPORT, 
2510        /**
2511         * A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.
2512         */
2513        MEDIA, 
2514        /**
2515         * Administration of medication to a patient.
2516         */
2517        MEDICATIONADMINISTRATION, 
2518        /**
2519         * Dispensing a medication to a named patient.
2520         */
2521        MEDICATIONDISPENSE, 
2522        /**
2523         * Record of medication being taken by a patient.
2524         */
2525        MEDICATIONSTATEMENT, 
2526        /**
2527         * Measurements and simple assertions.
2528         */
2529        OBSERVATION, 
2530        /**
2531         * PaymentNotice request.
2532         */
2533        PAYMENTNOTICE, 
2534        /**
2535         * PaymentReconciliation resource.
2536         */
2537        PAYMENTRECONCILIATION, 
2538        /**
2539         * An action that is being or was performed on a patient.
2540         */
2541        PROCEDURE, 
2542        /**
2543         * ProcessResponse resource.
2544         */
2545        PROCESSRESPONSE, 
2546        /**
2547         * A structured set of questions and their answers.
2548         */
2549        QUESTIONNAIRERESPONSE, 
2550        /**
2551         * Potential outcomes for a subject with likelihood.
2552         */
2553        RISKASSESSMENT, 
2554        /**
2555         * Delivery of bulk Supplies.
2556         */
2557        SUPPLYDELIVERY, 
2558        /**
2559         * A task to be performed.
2560         */
2561        TASK, 
2562        /**
2563         * added to help the parsers
2564         */
2565        NULL;
2566        public static EventResourceType fromCode(String codeString) throws FHIRException {
2567            if (codeString == null || "".equals(codeString))
2568                return null;
2569        if ("ChargeItem".equals(codeString))
2570          return CHARGEITEM;
2571        if ("ClaimResponse".equals(codeString))
2572          return CLAIMRESPONSE;
2573        if ("ClinicalImpression".equals(codeString))
2574          return CLINICALIMPRESSION;
2575        if ("Communication".equals(codeString))
2576          return COMMUNICATION;
2577        if ("Composition".equals(codeString))
2578          return COMPOSITION;
2579        if ("Condition".equals(codeString))
2580          return CONDITION;
2581        if ("Consent".equals(codeString))
2582          return CONSENT;
2583        if ("Coverage".equals(codeString))
2584          return COVERAGE;
2585        if ("DeviceUseStatement".equals(codeString))
2586          return DEVICEUSESTATEMENT;
2587        if ("DiagnosticReport".equals(codeString))
2588          return DIAGNOSTICREPORT;
2589        if ("DocumentManifest".equals(codeString))
2590          return DOCUMENTMANIFEST;
2591        if ("DocumentReference".equals(codeString))
2592          return DOCUMENTREFERENCE;
2593        if ("Encounter".equals(codeString))
2594          return ENCOUNTER;
2595        if ("EnrollmentResponse".equals(codeString))
2596          return ENROLLMENTRESPONSE;
2597        if ("EpisodeOfCare".equals(codeString))
2598          return EPISODEOFCARE;
2599        if ("ExplanationOfBenefit".equals(codeString))
2600          return EXPLANATIONOFBENEFIT;
2601        if ("FamilyMemberHistory".equals(codeString))
2602          return FAMILYMEMBERHISTORY;
2603        if ("GuidanceResponse".equals(codeString))
2604          return GUIDANCERESPONSE;
2605        if ("ImagingStudy".equals(codeString))
2606          return IMAGINGSTUDY;
2607        if ("Immunization".equals(codeString))
2608          return IMMUNIZATION;
2609        if ("MeasureReport".equals(codeString))
2610          return MEASUREREPORT;
2611        if ("Media".equals(codeString))
2612          return MEDIA;
2613        if ("MedicationAdministration".equals(codeString))
2614          return MEDICATIONADMINISTRATION;
2615        if ("MedicationDispense".equals(codeString))
2616          return MEDICATIONDISPENSE;
2617        if ("MedicationStatement".equals(codeString))
2618          return MEDICATIONSTATEMENT;
2619        if ("Observation".equals(codeString))
2620          return OBSERVATION;
2621        if ("PaymentNotice".equals(codeString))
2622          return PAYMENTNOTICE;
2623        if ("PaymentReconciliation".equals(codeString))
2624          return PAYMENTRECONCILIATION;
2625        if ("Procedure".equals(codeString))
2626          return PROCEDURE;
2627        if ("ProcessResponse".equals(codeString))
2628          return PROCESSRESPONSE;
2629        if ("QuestionnaireResponse".equals(codeString))
2630          return QUESTIONNAIRERESPONSE;
2631        if ("RiskAssessment".equals(codeString))
2632          return RISKASSESSMENT;
2633        if ("SupplyDelivery".equals(codeString))
2634          return SUPPLYDELIVERY;
2635        if ("Task".equals(codeString))
2636          return TASK;
2637        throw new FHIRException("Unknown EventResourceType code '"+codeString+"'");
2638        }
2639        public String toCode() {
2640          switch (this) {
2641            case CHARGEITEM: return "ChargeItem";
2642            case CLAIMRESPONSE: return "ClaimResponse";
2643            case CLINICALIMPRESSION: return "ClinicalImpression";
2644            case COMMUNICATION: return "Communication";
2645            case COMPOSITION: return "Composition";
2646            case CONDITION: return "Condition";
2647            case CONSENT: return "Consent";
2648            case COVERAGE: return "Coverage";
2649            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
2650            case DIAGNOSTICREPORT: return "DiagnosticReport";
2651            case DOCUMENTMANIFEST: return "DocumentManifest";
2652            case DOCUMENTREFERENCE: return "DocumentReference";
2653            case ENCOUNTER: return "Encounter";
2654            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
2655            case EPISODEOFCARE: return "EpisodeOfCare";
2656            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
2657            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
2658            case GUIDANCERESPONSE: return "GuidanceResponse";
2659            case IMAGINGSTUDY: return "ImagingStudy";
2660            case IMMUNIZATION: return "Immunization";
2661            case MEASUREREPORT: return "MeasureReport";
2662            case MEDIA: return "Media";
2663            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
2664            case MEDICATIONDISPENSE: return "MedicationDispense";
2665            case MEDICATIONSTATEMENT: return "MedicationStatement";
2666            case OBSERVATION: return "Observation";
2667            case PAYMENTNOTICE: return "PaymentNotice";
2668            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
2669            case PROCEDURE: return "Procedure";
2670            case PROCESSRESPONSE: return "ProcessResponse";
2671            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
2672            case RISKASSESSMENT: return "RiskAssessment";
2673            case SUPPLYDELIVERY: return "SupplyDelivery";
2674            case TASK: return "Task";
2675            case NULL: return null;
2676            default: return "?";
2677          }
2678        }
2679        public String getSystem() {
2680          switch (this) {
2681            case CHARGEITEM: return "http://hl7.org/fhir/event-resource-types";
2682            case CLAIMRESPONSE: return "http://hl7.org/fhir/event-resource-types";
2683            case CLINICALIMPRESSION: return "http://hl7.org/fhir/event-resource-types";
2684            case COMMUNICATION: return "http://hl7.org/fhir/event-resource-types";
2685            case COMPOSITION: return "http://hl7.org/fhir/event-resource-types";
2686            case CONDITION: return "http://hl7.org/fhir/event-resource-types";
2687            case CONSENT: return "http://hl7.org/fhir/event-resource-types";
2688            case COVERAGE: return "http://hl7.org/fhir/event-resource-types";
2689            case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/event-resource-types";
2690            case DIAGNOSTICREPORT: return "http://hl7.org/fhir/event-resource-types";
2691            case DOCUMENTMANIFEST: return "http://hl7.org/fhir/event-resource-types";
2692            case DOCUMENTREFERENCE: return "http://hl7.org/fhir/event-resource-types";
2693            case ENCOUNTER: return "http://hl7.org/fhir/event-resource-types";
2694            case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/event-resource-types";
2695            case EPISODEOFCARE: return "http://hl7.org/fhir/event-resource-types";
2696            case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/event-resource-types";
2697            case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/event-resource-types";
2698            case GUIDANCERESPONSE: return "http://hl7.org/fhir/event-resource-types";
2699            case IMAGINGSTUDY: return "http://hl7.org/fhir/event-resource-types";
2700            case IMMUNIZATION: return "http://hl7.org/fhir/event-resource-types";
2701            case MEASUREREPORT: return "http://hl7.org/fhir/event-resource-types";
2702            case MEDIA: return "http://hl7.org/fhir/event-resource-types";
2703            case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/event-resource-types";
2704            case MEDICATIONDISPENSE: return "http://hl7.org/fhir/event-resource-types";
2705            case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/event-resource-types";
2706            case OBSERVATION: return "http://hl7.org/fhir/event-resource-types";
2707            case PAYMENTNOTICE: return "http://hl7.org/fhir/event-resource-types";
2708            case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/event-resource-types";
2709            case PROCEDURE: return "http://hl7.org/fhir/event-resource-types";
2710            case PROCESSRESPONSE: return "http://hl7.org/fhir/event-resource-types";
2711            case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/event-resource-types";
2712            case RISKASSESSMENT: return "http://hl7.org/fhir/event-resource-types";
2713            case SUPPLYDELIVERY: return "http://hl7.org/fhir/event-resource-types";
2714            case TASK: return "http://hl7.org/fhir/event-resource-types";
2715            case NULL: return null;
2716            default: return "?";
2717          }
2718        }
2719        public String getDefinition() {
2720          switch (this) {
2721            case CHARGEITEM: return "Item containing charge code(s) associated with the provision of healthcare provider products.";
2722            case CLAIMRESPONSE: return "Remittance resource.";
2723            case CLINICALIMPRESSION: return "A clinical assessment performed when planning treatments and management strategies for a patient.";
2724            case COMMUNICATION: return "A record of information transmitted from a sender to a receiver.";
2725            case COMPOSITION: return "A set of resources composed into a single coherent clinical statement with clinical attestation.";
2726            case CONDITION: return "Detailed information about conditions, problems or diagnoses.";
2727            case CONSENT: return "A healthcare consumer's policy choices to permits or denies recipients or roles to perform actions for specific purposes and periods of time.";
2728            case COVERAGE: return "Insurance or medical plan or a payment agreement.";
2729            case DEVICEUSESTATEMENT: return "Record of use of a device.";
2730            case DIAGNOSTICREPORT: return "A Diagnostic report - a combination of request information, atomic results, images, interpretation, as well as formatted reports.";
2731            case DOCUMENTMANIFEST: return "A list that defines a set of documents.";
2732            case DOCUMENTREFERENCE: return "A reference to a document.";
2733            case ENCOUNTER: return "An interaction during which services are provided to the patient.";
2734            case ENROLLMENTRESPONSE: return "EnrollmentResponse resource.";
2735            case EPISODEOFCARE: return "An association of a Patient with an Organization and  Healthcare Provider(s) for a period of time that the Organization assumes some level of responsibility.";
2736            case EXPLANATIONOFBENEFIT: return "Explanation of Benefit resource.";
2737            case FAMILYMEMBERHISTORY: return "Information about patient's relatives, relevant for patient.";
2738            case GUIDANCERESPONSE: return "The formal response to a guidance request.";
2739            case IMAGINGSTUDY: return "A set of images produced in single study (one or more series of references images).";
2740            case IMMUNIZATION: return "Immunization event information.";
2741            case MEASUREREPORT: return "Results of a measure evaluation.";
2742            case MEDIA: return "A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.";
2743            case MEDICATIONADMINISTRATION: return "Administration of medication to a patient.";
2744            case MEDICATIONDISPENSE: return "Dispensing a medication to a named patient.";
2745            case MEDICATIONSTATEMENT: return "Record of medication being taken by a patient.";
2746            case OBSERVATION: return "Measurements and simple assertions.";
2747            case PAYMENTNOTICE: return "PaymentNotice request.";
2748            case PAYMENTRECONCILIATION: return "PaymentReconciliation resource.";
2749            case PROCEDURE: return "An action that is being or was performed on a patient.";
2750            case PROCESSRESPONSE: return "ProcessResponse resource.";
2751            case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers.";
2752            case RISKASSESSMENT: return "Potential outcomes for a subject with likelihood.";
2753            case SUPPLYDELIVERY: return "Delivery of bulk Supplies.";
2754            case TASK: return "A task to be performed.";
2755            case NULL: return null;
2756            default: return "?";
2757          }
2758        }
2759        public String getDisplay() {
2760          switch (this) {
2761            case CHARGEITEM: return "ChargeItem";
2762            case CLAIMRESPONSE: return "ClaimResponse";
2763            case CLINICALIMPRESSION: return "ClinicalImpression";
2764            case COMMUNICATION: return "Communication";
2765            case COMPOSITION: return "Composition";
2766            case CONDITION: return "Condition";
2767            case CONSENT: return "Consent";
2768            case COVERAGE: return "Coverage";
2769            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
2770            case DIAGNOSTICREPORT: return "DiagnosticReport";
2771            case DOCUMENTMANIFEST: return "DocumentManifest";
2772            case DOCUMENTREFERENCE: return "DocumentReference";
2773            case ENCOUNTER: return "Encounter";
2774            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
2775            case EPISODEOFCARE: return "EpisodeOfCare";
2776            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
2777            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
2778            case GUIDANCERESPONSE: return "GuidanceResponse";
2779            case IMAGINGSTUDY: return "ImagingStudy";
2780            case IMMUNIZATION: return "Immunization";
2781            case MEASUREREPORT: return "MeasureReport";
2782            case MEDIA: return "Media";
2783            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
2784            case MEDICATIONDISPENSE: return "MedicationDispense";
2785            case MEDICATIONSTATEMENT: return "MedicationStatement";
2786            case OBSERVATION: return "Observation";
2787            case PAYMENTNOTICE: return "PaymentNotice";
2788            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
2789            case PROCEDURE: return "Procedure";
2790            case PROCESSRESPONSE: return "ProcessResponse";
2791            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
2792            case RISKASSESSMENT: return "RiskAssessment";
2793            case SUPPLYDELIVERY: return "SupplyDelivery";
2794            case TASK: return "Task";
2795            case NULL: return null;
2796            default: return "?";
2797          }
2798        }
2799    }
2800
2801  public static class EventResourceTypeEnumFactory implements EnumFactory<EventResourceType> {
2802    public EventResourceType fromCode(String codeString) throws IllegalArgumentException {
2803      if (codeString == null || "".equals(codeString))
2804            if (codeString == null || "".equals(codeString))
2805                return null;
2806        if ("ChargeItem".equals(codeString))
2807          return EventResourceType.CHARGEITEM;
2808        if ("ClaimResponse".equals(codeString))
2809          return EventResourceType.CLAIMRESPONSE;
2810        if ("ClinicalImpression".equals(codeString))
2811          return EventResourceType.CLINICALIMPRESSION;
2812        if ("Communication".equals(codeString))
2813          return EventResourceType.COMMUNICATION;
2814        if ("Composition".equals(codeString))
2815          return EventResourceType.COMPOSITION;
2816        if ("Condition".equals(codeString))
2817          return EventResourceType.CONDITION;
2818        if ("Consent".equals(codeString))
2819          return EventResourceType.CONSENT;
2820        if ("Coverage".equals(codeString))
2821          return EventResourceType.COVERAGE;
2822        if ("DeviceUseStatement".equals(codeString))
2823          return EventResourceType.DEVICEUSESTATEMENT;
2824        if ("DiagnosticReport".equals(codeString))
2825          return EventResourceType.DIAGNOSTICREPORT;
2826        if ("DocumentManifest".equals(codeString))
2827          return EventResourceType.DOCUMENTMANIFEST;
2828        if ("DocumentReference".equals(codeString))
2829          return EventResourceType.DOCUMENTREFERENCE;
2830        if ("Encounter".equals(codeString))
2831          return EventResourceType.ENCOUNTER;
2832        if ("EnrollmentResponse".equals(codeString))
2833          return EventResourceType.ENROLLMENTRESPONSE;
2834        if ("EpisodeOfCare".equals(codeString))
2835          return EventResourceType.EPISODEOFCARE;
2836        if ("ExplanationOfBenefit".equals(codeString))
2837          return EventResourceType.EXPLANATIONOFBENEFIT;
2838        if ("FamilyMemberHistory".equals(codeString))
2839          return EventResourceType.FAMILYMEMBERHISTORY;
2840        if ("GuidanceResponse".equals(codeString))
2841          return EventResourceType.GUIDANCERESPONSE;
2842        if ("ImagingStudy".equals(codeString))
2843          return EventResourceType.IMAGINGSTUDY;
2844        if ("Immunization".equals(codeString))
2845          return EventResourceType.IMMUNIZATION;
2846        if ("MeasureReport".equals(codeString))
2847          return EventResourceType.MEASUREREPORT;
2848        if ("Media".equals(codeString))
2849          return EventResourceType.MEDIA;
2850        if ("MedicationAdministration".equals(codeString))
2851          return EventResourceType.MEDICATIONADMINISTRATION;
2852        if ("MedicationDispense".equals(codeString))
2853          return EventResourceType.MEDICATIONDISPENSE;
2854        if ("MedicationStatement".equals(codeString))
2855          return EventResourceType.MEDICATIONSTATEMENT;
2856        if ("Observation".equals(codeString))
2857          return EventResourceType.OBSERVATION;
2858        if ("PaymentNotice".equals(codeString))
2859          return EventResourceType.PAYMENTNOTICE;
2860        if ("PaymentReconciliation".equals(codeString))
2861          return EventResourceType.PAYMENTRECONCILIATION;
2862        if ("Procedure".equals(codeString))
2863          return EventResourceType.PROCEDURE;
2864        if ("ProcessResponse".equals(codeString))
2865          return EventResourceType.PROCESSRESPONSE;
2866        if ("QuestionnaireResponse".equals(codeString))
2867          return EventResourceType.QUESTIONNAIRERESPONSE;
2868        if ("RiskAssessment".equals(codeString))
2869          return EventResourceType.RISKASSESSMENT;
2870        if ("SupplyDelivery".equals(codeString))
2871          return EventResourceType.SUPPLYDELIVERY;
2872        if ("Task".equals(codeString))
2873          return EventResourceType.TASK;
2874        throw new IllegalArgumentException("Unknown EventResourceType code '"+codeString+"'");
2875        }
2876        public Enumeration<EventResourceType> fromType(PrimitiveType<?> code) throws FHIRException {
2877          if (code == null)
2878            return null;
2879          if (code.isEmpty())
2880            return new Enumeration<EventResourceType>(this, EventResourceType.NULL, code);
2881          String codeString = code.asStringValue();
2882          if (codeString == null || "".equals(codeString))
2883            return new Enumeration<EventResourceType>(this, EventResourceType.NULL, code);
2884        if ("ChargeItem".equals(codeString))
2885          return new Enumeration<EventResourceType>(this, EventResourceType.CHARGEITEM, code);
2886        if ("ClaimResponse".equals(codeString))
2887          return new Enumeration<EventResourceType>(this, EventResourceType.CLAIMRESPONSE, code);
2888        if ("ClinicalImpression".equals(codeString))
2889          return new Enumeration<EventResourceType>(this, EventResourceType.CLINICALIMPRESSION, code);
2890        if ("Communication".equals(codeString))
2891          return new Enumeration<EventResourceType>(this, EventResourceType.COMMUNICATION, code);
2892        if ("Composition".equals(codeString))
2893          return new Enumeration<EventResourceType>(this, EventResourceType.COMPOSITION, code);
2894        if ("Condition".equals(codeString))
2895          return new Enumeration<EventResourceType>(this, EventResourceType.CONDITION, code);
2896        if ("Consent".equals(codeString))
2897          return new Enumeration<EventResourceType>(this, EventResourceType.CONSENT, code);
2898        if ("Coverage".equals(codeString))
2899          return new Enumeration<EventResourceType>(this, EventResourceType.COVERAGE, code);
2900        if ("DeviceUseStatement".equals(codeString))
2901          return new Enumeration<EventResourceType>(this, EventResourceType.DEVICEUSESTATEMENT, code);
2902        if ("DiagnosticReport".equals(codeString))
2903          return new Enumeration<EventResourceType>(this, EventResourceType.DIAGNOSTICREPORT, code);
2904        if ("DocumentManifest".equals(codeString))
2905          return new Enumeration<EventResourceType>(this, EventResourceType.DOCUMENTMANIFEST, code);
2906        if ("DocumentReference".equals(codeString))
2907          return new Enumeration<EventResourceType>(this, EventResourceType.DOCUMENTREFERENCE, code);
2908        if ("Encounter".equals(codeString))
2909          return new Enumeration<EventResourceType>(this, EventResourceType.ENCOUNTER, code);
2910        if ("EnrollmentResponse".equals(codeString))
2911          return new Enumeration<EventResourceType>(this, EventResourceType.ENROLLMENTRESPONSE, code);
2912        if ("EpisodeOfCare".equals(codeString))
2913          return new Enumeration<EventResourceType>(this, EventResourceType.EPISODEOFCARE, code);
2914        if ("ExplanationOfBenefit".equals(codeString))
2915          return new Enumeration<EventResourceType>(this, EventResourceType.EXPLANATIONOFBENEFIT, code);
2916        if ("FamilyMemberHistory".equals(codeString))
2917          return new Enumeration<EventResourceType>(this, EventResourceType.FAMILYMEMBERHISTORY, code);
2918        if ("GuidanceResponse".equals(codeString))
2919          return new Enumeration<EventResourceType>(this, EventResourceType.GUIDANCERESPONSE, code);
2920        if ("ImagingStudy".equals(codeString))
2921          return new Enumeration<EventResourceType>(this, EventResourceType.IMAGINGSTUDY, code);
2922        if ("Immunization".equals(codeString))
2923          return new Enumeration<EventResourceType>(this, EventResourceType.IMMUNIZATION, code);
2924        if ("MeasureReport".equals(codeString))
2925          return new Enumeration<EventResourceType>(this, EventResourceType.MEASUREREPORT, code);
2926        if ("Media".equals(codeString))
2927          return new Enumeration<EventResourceType>(this, EventResourceType.MEDIA, code);
2928        if ("MedicationAdministration".equals(codeString))
2929          return new Enumeration<EventResourceType>(this, EventResourceType.MEDICATIONADMINISTRATION, code);
2930        if ("MedicationDispense".equals(codeString))
2931          return new Enumeration<EventResourceType>(this, EventResourceType.MEDICATIONDISPENSE, code);
2932        if ("MedicationStatement".equals(codeString))
2933          return new Enumeration<EventResourceType>(this, EventResourceType.MEDICATIONSTATEMENT, code);
2934        if ("Observation".equals(codeString))
2935          return new Enumeration<EventResourceType>(this, EventResourceType.OBSERVATION, code);
2936        if ("PaymentNotice".equals(codeString))
2937          return new Enumeration<EventResourceType>(this, EventResourceType.PAYMENTNOTICE, code);
2938        if ("PaymentReconciliation".equals(codeString))
2939          return new Enumeration<EventResourceType>(this, EventResourceType.PAYMENTRECONCILIATION, code);
2940        if ("Procedure".equals(codeString))
2941          return new Enumeration<EventResourceType>(this, EventResourceType.PROCEDURE, code);
2942        if ("ProcessResponse".equals(codeString))
2943          return new Enumeration<EventResourceType>(this, EventResourceType.PROCESSRESPONSE, code);
2944        if ("QuestionnaireResponse".equals(codeString))
2945          return new Enumeration<EventResourceType>(this, EventResourceType.QUESTIONNAIRERESPONSE, code);
2946        if ("RiskAssessment".equals(codeString))
2947          return new Enumeration<EventResourceType>(this, EventResourceType.RISKASSESSMENT, code);
2948        if ("SupplyDelivery".equals(codeString))
2949          return new Enumeration<EventResourceType>(this, EventResourceType.SUPPLYDELIVERY, code);
2950        if ("Task".equals(codeString))
2951          return new Enumeration<EventResourceType>(this, EventResourceType.TASK, code);
2952        throw new FHIRException("Unknown EventResourceType code '"+codeString+"'");
2953        }
2954    public String toCode(EventResourceType code) {
2955      if (code == EventResourceType.CHARGEITEM)
2956        return "ChargeItem";
2957      if (code == EventResourceType.CLAIMRESPONSE)
2958        return "ClaimResponse";
2959      if (code == EventResourceType.CLINICALIMPRESSION)
2960        return "ClinicalImpression";
2961      if (code == EventResourceType.COMMUNICATION)
2962        return "Communication";
2963      if (code == EventResourceType.COMPOSITION)
2964        return "Composition";
2965      if (code == EventResourceType.CONDITION)
2966        return "Condition";
2967      if (code == EventResourceType.CONSENT)
2968        return "Consent";
2969      if (code == EventResourceType.COVERAGE)
2970        return "Coverage";
2971      if (code == EventResourceType.DEVICEUSESTATEMENT)
2972        return "DeviceUseStatement";
2973      if (code == EventResourceType.DIAGNOSTICREPORT)
2974        return "DiagnosticReport";
2975      if (code == EventResourceType.DOCUMENTMANIFEST)
2976        return "DocumentManifest";
2977      if (code == EventResourceType.DOCUMENTREFERENCE)
2978        return "DocumentReference";
2979      if (code == EventResourceType.ENCOUNTER)
2980        return "Encounter";
2981      if (code == EventResourceType.ENROLLMENTRESPONSE)
2982        return "EnrollmentResponse";
2983      if (code == EventResourceType.EPISODEOFCARE)
2984        return "EpisodeOfCare";
2985      if (code == EventResourceType.EXPLANATIONOFBENEFIT)
2986        return "ExplanationOfBenefit";
2987      if (code == EventResourceType.FAMILYMEMBERHISTORY)
2988        return "FamilyMemberHistory";
2989      if (code == EventResourceType.GUIDANCERESPONSE)
2990        return "GuidanceResponse";
2991      if (code == EventResourceType.IMAGINGSTUDY)
2992        return "ImagingStudy";
2993      if (code == EventResourceType.IMMUNIZATION)
2994        return "Immunization";
2995      if (code == EventResourceType.MEASUREREPORT)
2996        return "MeasureReport";
2997      if (code == EventResourceType.MEDIA)
2998        return "Media";
2999      if (code == EventResourceType.MEDICATIONADMINISTRATION)
3000        return "MedicationAdministration";
3001      if (code == EventResourceType.MEDICATIONDISPENSE)
3002        return "MedicationDispense";
3003      if (code == EventResourceType.MEDICATIONSTATEMENT)
3004        return "MedicationStatement";
3005      if (code == EventResourceType.OBSERVATION)
3006        return "Observation";
3007      if (code == EventResourceType.PAYMENTNOTICE)
3008        return "PaymentNotice";
3009      if (code == EventResourceType.PAYMENTRECONCILIATION)
3010        return "PaymentReconciliation";
3011      if (code == EventResourceType.PROCEDURE)
3012        return "Procedure";
3013      if (code == EventResourceType.PROCESSRESPONSE)
3014        return "ProcessResponse";
3015      if (code == EventResourceType.QUESTIONNAIRERESPONSE)
3016        return "QuestionnaireResponse";
3017      if (code == EventResourceType.RISKASSESSMENT)
3018        return "RiskAssessment";
3019      if (code == EventResourceType.SUPPLYDELIVERY)
3020        return "SupplyDelivery";
3021      if (code == EventResourceType.TASK)
3022        return "Task";
3023      return "?";
3024      }
3025    public String toSystem(EventResourceType code) {
3026      return code.getSystem();
3027      }
3028    }
3029
3030    public enum FHIRAllTypes {
3031        /**
3032         * An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.
3033         */
3034        ADDRESS, 
3035        /**
3036         * A duration of time during which an organism (or a process) has existed.
3037         */
3038        AGE, 
3039        /**
3040         * A  text note which also  contains information about who made the statement and when.
3041         */
3042        ANNOTATION, 
3043        /**
3044         * For referring to data content defined in other formats.
3045         */
3046        ATTACHMENT, 
3047        /**
3048         * Base definition for all elements that are defined inside a resource - but not those in a data type.
3049         */
3050        BACKBONEELEMENT, 
3051        /**
3052         * A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
3053         */
3054        CODEABLECONCEPT, 
3055        /**
3056         * A reference to a code defined by a terminology system.
3057         */
3058        CODING, 
3059        /**
3060         * Specifies contact information for a person or organization.
3061         */
3062        CONTACTDETAIL, 
3063        /**
3064         * Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
3065         */
3066        CONTACTPOINT, 
3067        /**
3068         * A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
3069         */
3070        CONTRIBUTOR, 
3071        /**
3072         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
3073         */
3074        COUNT, 
3075        /**
3076         * Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
3077         */
3078        DATAREQUIREMENT, 
3079        /**
3080         * A length - a value with a unit that is a physical distance.
3081         */
3082        DISTANCE, 
3083        /**
3084         * Indicates how the medication is/was taken or should be taken by the patient.
3085         */
3086        DOSAGE, 
3087        /**
3088         * A length of time.
3089         */
3090        DURATION, 
3091        /**
3092         * Base definition for all elements in a resource.
3093         */
3094        ELEMENT, 
3095        /**
3096         * Captures constraints on each element within the resource, profile, or extension.
3097         */
3098        ELEMENTDEFINITION, 
3099        /**
3100         * A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
3101         */
3102        EXPRESSION, 
3103        /**
3104         * Optional Extension Element - found in all resources.
3105         */
3106        EXTENSION, 
3107        /**
3108         * A human's name with the ability to identify parts and usage.
3109         */
3110        HUMANNAME, 
3111        /**
3112         * An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
3113         */
3114        IDENTIFIER, 
3115        /**
3116         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
3117         */
3118        MARKETINGSTATUS, 
3119        /**
3120         * The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
3121         */
3122        META, 
3123        /**
3124         * An amount of economic utility in some recognized currency.
3125         */
3126        MONEY, 
3127        /**
3128         * null
3129         */
3130        MONEYQUANTITY, 
3131        /**
3132         * A human-readable summary of the resource conveying the essential clinical and business information for the resource.
3133         */
3134        NARRATIVE, 
3135        /**
3136         * The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
3137         */
3138        PARAMETERDEFINITION, 
3139        /**
3140         * A time period defined by a start and end date and optionally time.
3141         */
3142        PERIOD, 
3143        /**
3144         * A populatioof people with some set of grouping criteria.
3145         */
3146        POPULATION, 
3147        /**
3148         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
3149         */
3150        PRODCHARACTERISTIC, 
3151        /**
3152         * The shelf-life and storage information for a medicinal product item or container can be described using this class.
3153         */
3154        PRODUCTSHELFLIFE, 
3155        /**
3156         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
3157         */
3158        QUANTITY, 
3159        /**
3160         * A set of ordered Quantities defined by a low and high limit.
3161         */
3162        RANGE, 
3163        /**
3164         * A relationship of two Quantity values - expressed as a numerator and a denominator.
3165         */
3166        RATIO, 
3167        /**
3168         * A reference from one resource to another.
3169         */
3170        REFERENCE, 
3171        /**
3172         * Related artifacts such as additional documentation, justification, or bibliographic references.
3173         */
3174        RELATEDARTIFACT, 
3175        /**
3176         * A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
3177         */
3178        SAMPLEDDATA, 
3179        /**
3180         * A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
3181         */
3182        SIGNATURE, 
3183        /**
3184         * null
3185         */
3186        SIMPLEQUANTITY, 
3187        /**
3188         * Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.
3189         */
3190        SUBSTANCEAMOUNT, 
3191        /**
3192         * Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
3193         */
3194        TIMING, 
3195        /**
3196         * A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
3197         */
3198        TRIGGERDEFINITION, 
3199        /**
3200         * Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
3201         */
3202        USAGECONTEXT, 
3203        /**
3204         * A stream of bytes
3205         */
3206        BASE64BINARY, 
3207        /**
3208         * Value of "true" or "false"
3209         */
3210        BOOLEAN, 
3211        /**
3212         * A URI that is a reference to a canonical URL on a FHIR resource
3213         */
3214        CANONICAL, 
3215        /**
3216         * A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
3217         */
3218        CODE, 
3219        /**
3220         * A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
3221         */
3222        DATE, 
3223        /**
3224         * A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.
3225         */
3226        DATETIME, 
3227        /**
3228         * A rational number with implicit precision
3229         */
3230        DECIMAL, 
3231        /**
3232         * Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.
3233         */
3234        ID, 
3235        /**
3236         * An instant in time - known at least to the second
3237         */
3238        INSTANT, 
3239        /**
3240         * A whole number
3241         */
3242        INTEGER, 
3243        /**
3244         * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
3245         */
3246        MARKDOWN, 
3247        /**
3248         * An OID represented as a URI
3249         */
3250        OID, 
3251        /**
3252         * An integer with a value that is positive (e.g. >0)
3253         */
3254        POSITIVEINT, 
3255        /**
3256         * A sequence of Unicode characters
3257         */
3258        STRING, 
3259        /**
3260         * A time during the day, with no date specified
3261         */
3262        TIME, 
3263        /**
3264         * An integer with a value that is not negative (e.g. >= 0)
3265         */
3266        UNSIGNEDINT, 
3267        /**
3268         * String of characters used to identify a name or a resource
3269         */
3270        URI, 
3271        /**
3272         * A URI that is a literal reference
3273         */
3274        URL, 
3275        /**
3276         * A UUID, represented as a URI
3277         */
3278        UUID, 
3279        /**
3280         * XHTML format, as defined by W3C, but restricted usage (mainly, no active content)
3281         */
3282        XHTML, 
3283        /**
3284         * A financial tool for tracking value accrued for a particular purpose.  In the healthcare field, used to track charges for a patient, cost centers, etc.
3285         */
3286        ACCOUNT, 
3287        /**
3288         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
3289         */
3290        ACTIVITYDEFINITION, 
3291        /**
3292         * Actual or  potential/avoided event causing unintended physical injury resulting from or contributed to by medical care, a research study or other healthcare setting factors that requires additional monitoring, treatment, or hospitalization, or that results in death.
3293         */
3294        ADVERSEEVENT, 
3295        /**
3296         * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.
3297         */
3298        ALLERGYINTOLERANCE, 
3299        /**
3300         * A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s).
3301         */
3302        APPOINTMENT, 
3303        /**
3304         * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.
3305         */
3306        APPOINTMENTRESPONSE, 
3307        /**
3308         * A record of an event made for purposes of maintaining a security log. Typical uses include detection of intrusion attempts and monitoring for inappropriate usage.
3309         */
3310        AUDITEVENT, 
3311        /**
3312         * Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification.
3313         */
3314        BASIC, 
3315        /**
3316         * A resource that represents the data of a single raw artifact as digital content accessible in its native format.  A Binary resource can contain any content, whether text, image, pdf, zip archive, etc.
3317         */
3318        BINARY, 
3319        /**
3320         * A material substance originating from a biological entity intended to be transplanted or infused
3321into another (possibly the same) biological entity.
3322         */
3323        BIOLOGICALLYDERIVEDPRODUCT, 
3324        /**
3325         * Record details about an anatomical structure.  This resource may be used when a coded concept does not provide the necessary detail needed for the use case.
3326         */
3327        BODYSTRUCTURE, 
3328        /**
3329         * A container for a collection of resources.
3330         */
3331        BUNDLE, 
3332        /**
3333         * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
3334         */
3335        CAPABILITYSTATEMENT, 
3336        /**
3337         * Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions.
3338         */
3339        CAREPLAN, 
3340        /**
3341         * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care for a patient.
3342         */
3343        CARETEAM, 
3344        /**
3345         * Catalog entries are wrappers that contextualize items included in a catalog.
3346         */
3347        CATALOGENTRY, 
3348        /**
3349         * The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation.
3350         */
3351        CHARGEITEM, 
3352        /**
3353         * The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system.
3354         */
3355        CHARGEITEMDEFINITION, 
3356        /**
3357         * A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement.
3358         */
3359        CLAIM, 
3360        /**
3361         * This resource provides the adjudication details from the processing of a Claim resource.
3362         */
3363        CLAIMRESPONSE, 
3364        /**
3365         * A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter,  but this varies greatly depending on the clinical workflow. This resource is called "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with the recording of assessment tools such as Apgar score.
3366         */
3367        CLINICALIMPRESSION, 
3368        /**
3369         * 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.
3370         */
3371        CODESYSTEM, 
3372        /**
3373         * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition.
3374         */
3375        COMMUNICATION, 
3376        /**
3377         * A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition.
3378         */
3379        COMMUNICATIONREQUEST, 
3380        /**
3381         * A compartment definition that defines how resources are accessed on a server.
3382         */
3383        COMPARTMENTDEFINITION, 
3384        /**
3385         * A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.).
3386         */
3387        COMPOSITION, 
3388        /**
3389         * A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models.
3390         */
3391        CONCEPTMAP, 
3392        /**
3393         * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.
3394         */
3395        CONDITION, 
3396        /**
3397         * A record of a healthcare consumer?s  choices, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time.
3398         */
3399        CONSENT, 
3400        /**
3401         * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
3402         */
3403        CONTRACT, 
3404        /**
3405         * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.
3406         */
3407        COVERAGE, 
3408        /**
3409         * The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy.
3410         */
3411        COVERAGEELIGIBILITYREQUEST, 
3412        /**
3413         * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.
3414         */
3415        COVERAGEELIGIBILITYRESPONSE, 
3416        /**
3417         * Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc.
3418         */
3419        DETECTEDISSUE, 
3420        /**
3421         * A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.
3422         */
3423        DEVICE, 
3424        /**
3425         * The characteristics, operational status and capabilities of a medical-related component of a medical device.
3426         */
3427        DEVICEDEFINITION, 
3428        /**
3429         * Describes a measurement, calculation or setting capability of a medical device.
3430         */
3431        DEVICEMETRIC, 
3432        /**
3433         * Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker.
3434         */
3435        DEVICEREQUEST, 
3436        /**
3437         * A record of a device being used by a patient where the record is the result of a report from the patient or another clinician.
3438         */
3439        DEVICEUSESTATEMENT, 
3440        /**
3441         * The findings and interpretation of diagnostic  tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports.
3442         */
3443        DIAGNOSTICREPORT, 
3444        /**
3445         * A collection of documents compiled for a purpose together with metadata that applies to the collection.
3446         */
3447        DOCUMENTMANIFEST, 
3448        /**
3449         * A reference to a document of any kind for any purpose. Provides metadata about the document so that the document can be discovered and managed. The scope of a document is any seralized object with a mime-type, so includes formal patient centric documents (CDA), cliical notes, scanned paper, and non-patient specific documents like policy text.
3450         */
3451        DOCUMENTREFERENCE, 
3452        /**
3453         * A resource that includes narrative, extensions, and contained resources.
3454         */
3455        DOMAINRESOURCE, 
3456        /**
3457         * The EffectEvidenceSynthesis resource describes the difference in an outcome between exposures states in a population where the effect estimate is derived from a combination of research studies.
3458         */
3459        EFFECTEVIDENCESYNTHESIS, 
3460        /**
3461         * An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient.
3462         */
3463        ENCOUNTER, 
3464        /**
3465         * The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information.
3466         */
3467        ENDPOINT, 
3468        /**
3469         * This resource provides the insurance enrollment details to the insurer regarding a specified coverage.
3470         */
3471        ENROLLMENTREQUEST, 
3472        /**
3473         * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.
3474         */
3475        ENROLLMENTRESPONSE, 
3476        /**
3477         * An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time.
3478         */
3479        EPISODEOFCARE, 
3480        /**
3481         * The EventDefinition resource provides a reusable description of when a particular event can occur.
3482         */
3483        EVENTDEFINITION, 
3484        /**
3485         * The Evidence resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.
3486         */
3487        EVIDENCE, 
3488        /**
3489         * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
3490         */
3491        EVIDENCEVARIABLE, 
3492        /**
3493         * Example of workflow instance.
3494         */
3495        EXAMPLESCENARIO, 
3496        /**
3497         * This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided.
3498         */
3499        EXPLANATIONOFBENEFIT, 
3500        /**
3501         * Significant health conditions for a person related to the patient relevant in the context of care for the patient.
3502         */
3503        FAMILYMEMBERHISTORY, 
3504        /**
3505         * Prospective warnings of potential issues when providing care to the patient.
3506         */
3507        FLAG, 
3508        /**
3509         * Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.
3510         */
3511        GOAL, 
3512        /**
3513         * A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set.
3514         */
3515        GRAPHDEFINITION, 
3516        /**
3517         * Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization.
3518         */
3519        GROUP, 
3520        /**
3521         * A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken.
3522         */
3523        GUIDANCERESPONSE, 
3524        /**
3525         * The details of a healthcare service available at a location.
3526         */
3527        HEALTHCARESERVICE, 
3528        /**
3529         * Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context.  A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities.
3530         */
3531        IMAGINGSTUDY, 
3532        /**
3533         * Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party.
3534         */
3535        IMMUNIZATION, 
3536        /**
3537         * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations.
3538         */
3539        IMMUNIZATIONEVALUATION, 
3540        /**
3541         * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.
3542         */
3543        IMMUNIZATIONRECOMMENDATION, 
3544        /**
3545         * A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts.
3546         */
3547        IMPLEMENTATIONGUIDE, 
3548        /**
3549         * Details of a Health Insurance product/plan provided by an organization.
3550         */
3551        INSURANCEPLAN, 
3552        /**
3553         * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.
3554         */
3555        INVOICE, 
3556        /**
3557         * The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets.
3558         */
3559        LIBRARY, 
3560        /**
3561         * Identifies two or more records (resource instances) that refer to the same real-world "occurrence".
3562         */
3563        LINKAGE, 
3564        /**
3565         * A list is a curated collection of resources.
3566         */
3567        LIST, 
3568        /**
3569         * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.
3570         */
3571        LOCATION, 
3572        /**
3573         * The Measure resource provides the definition of a quality measure.
3574         */
3575        MEASURE, 
3576        /**
3577         * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.
3578         */
3579        MEASUREREPORT, 
3580        /**
3581         * A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.
3582         */
3583        MEDIA, 
3584        /**
3585         * This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use.
3586         */
3587        MEDICATION, 
3588        /**
3589         * Describes the event of a patient consuming or otherwise being administered a medication.  This may be as simple as swallowing a tablet or it may be a long running infusion.  Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner.
3590         */
3591        MEDICATIONADMINISTRATION, 
3592        /**
3593         * Indicates that a medication product is to be or has been dispensed for a named person/patient.  This includes a description of the medication product (supply) provided and the instructions for administering the medication.  The medication dispense is the result of a pharmacy system responding to a medication order.
3594         */
3595        MEDICATIONDISPENSE, 
3596        /**
3597         * Information about a medication that is used to support knowledge.
3598         */
3599        MEDICATIONKNOWLEDGE, 
3600        /**
3601         * An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called "MedicationRequest" rather than "MedicationPrescription" or "MedicationOrder" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns.
3602         */
3603        MEDICATIONREQUEST, 
3604        /**
3605         * A record of a medication that is being consumed by a patient.   A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future.  The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician.  A common scenario where this information is captured is during the history taking process during a patient visit or stay.   The medication information may come from sources such as the patient's memory, from a prescription bottle,  or from a list of medications the patient, clinician or other party maintains. 
3606
3607The primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medication statement is often, if not always, less specific.  There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise.  As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains.  Medication administration is more formal and is not missing detailed information.
3608         */
3609        MEDICATIONSTATEMENT, 
3610        /**
3611         * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).
3612         */
3613        MEDICINALPRODUCT, 
3614        /**
3615         * The regulatory authorization of a medicinal product.
3616         */
3617        MEDICINALPRODUCTAUTHORIZATION, 
3618        /**
3619         * The clinical particulars - indications, contraindications etc. of a medicinal product, including for regulatory purposes.
3620         */
3621        MEDICINALPRODUCTCONTRAINDICATION, 
3622        /**
3623         * Indication for the Medicinal Product.
3624         */
3625        MEDICINALPRODUCTINDICATION, 
3626        /**
3627         * An ingredient of a manufactured item or pharmaceutical product.
3628         */
3629        MEDICINALPRODUCTINGREDIENT, 
3630        /**
3631         * The interactions of the medicinal product with other medicinal products, or other forms of interactions.
3632         */
3633        MEDICINALPRODUCTINTERACTION, 
3634        /**
3635         * The manufactured item as contained in the packaged medicinal product.
3636         */
3637        MEDICINALPRODUCTMANUFACTURED, 
3638        /**
3639         * A medicinal product in a container or package.
3640         */
3641        MEDICINALPRODUCTPACKAGED, 
3642        /**
3643         * A pharmaceutical product described in terms of its composition and dose form.
3644         */
3645        MEDICINALPRODUCTPHARMACEUTICAL, 
3646        /**
3647         * Describe the undesirable effects of the medicinal product.
3648         */
3649        MEDICINALPRODUCTUNDESIRABLEEFFECT, 
3650        /**
3651         * Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted.
3652         */
3653        MESSAGEDEFINITION, 
3654        /**
3655         * The header for a message exchange that is either requesting or responding to an action.  The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle.
3656         */
3657        MESSAGEHEADER, 
3658        /**
3659         * Raw data describing a biological sequence.
3660         */
3661        MOLECULARSEQUENCE, 
3662        /**
3663         * A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc.  Represents a "System" used within the Identifier and Coding data types.
3664         */
3665        NAMINGSYSTEM, 
3666        /**
3667         * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.
3668         */
3669        NUTRITIONORDER, 
3670        /**
3671         * Measurements and simple assertions made about a patient, device or other subject.
3672         */
3673        OBSERVATION, 
3674        /**
3675         * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.
3676         */
3677        OBSERVATIONDEFINITION, 
3678        /**
3679         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
3680         */
3681        OPERATIONDEFINITION, 
3682        /**
3683         * A collection of error, warning, or information messages that result from a system action.
3684         */
3685        OPERATIONOUTCOME, 
3686        /**
3687         * A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action.  Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc.
3688         */
3689        ORGANIZATION, 
3690        /**
3691         * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.
3692         */
3693        ORGANIZATIONAFFILIATION, 
3694        /**
3695         * This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it.
3696         */
3697        PARAMETERS, 
3698        /**
3699         * Demographics and other administrative information about an individual or animal receiving care or other health-related services.
3700         */
3701        PATIENT, 
3702        /**
3703         * This resource provides the status of the payment for goods and services rendered, and the request and response resource references.
3704         */
3705        PAYMENTNOTICE, 
3706        /**
3707         * This resource provides the details including amount of a payment and allocates the payment items being paid.
3708         */
3709        PAYMENTRECONCILIATION, 
3710        /**
3711         * Demographics and administrative information about a person independent of a specific health-related context.
3712         */
3713        PERSON, 
3714        /**
3715         * This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.
3716         */
3717        PLANDEFINITION, 
3718        /**
3719         * A person who is directly or indirectly involved in the provisioning of healthcare.
3720         */
3721        PRACTITIONER, 
3722        /**
3723         * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.
3724         */
3725        PRACTITIONERROLE, 
3726        /**
3727         * An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy.
3728         */
3729        PROCEDURE, 
3730        /**
3731         * Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies.
3732         */
3733        PROVENANCE, 
3734        /**
3735         * A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.
3736         */
3737        QUESTIONNAIRE, 
3738        /**
3739         * A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to.
3740         */
3741        QUESTIONNAIRERESPONSE, 
3742        /**
3743         * Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.
3744         */
3745        RELATEDPERSON, 
3746        /**
3747         * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one".
3748         */
3749        REQUESTGROUP, 
3750        /**
3751         * The ResearchDefinition resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.
3752         */
3753        RESEARCHDEFINITION, 
3754        /**
3755         * The ResearchElementDefinition resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
3756         */
3757        RESEARCHELEMENTDEFINITION, 
3758        /**
3759         * A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge.  This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques.  A ResearchStudy involves the gathering of information about human or animal subjects.
3760         */
3761        RESEARCHSTUDY, 
3762        /**
3763         * A physical entity which is the primary unit of operational and/or administrative interest in a study.
3764         */
3765        RESEARCHSUBJECT, 
3766        /**
3767         * This is the base resource type for everything.
3768         */
3769        RESOURCE, 
3770        /**
3771         * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.
3772         */
3773        RISKASSESSMENT, 
3774        /**
3775         * The RiskEvidenceSynthesis resource describes the likelihood of an outcome in a population plus exposure state where the risk estimate is derived from a combination of research studies.
3776         */
3777        RISKEVIDENCESYNTHESIS, 
3778        /**
3779         * A container for slots of time that may be available for booking appointments.
3780         */
3781        SCHEDULE, 
3782        /**
3783         * A search parameter that defines a named search item that can be used to search/filter on a resource.
3784         */
3785        SEARCHPARAMETER, 
3786        /**
3787         * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.
3788         */
3789        SERVICEREQUEST, 
3790        /**
3791         * A slot of time on a schedule that may be available for booking appointments.
3792         */
3793        SLOT, 
3794        /**
3795         * A sample to be used for analysis.
3796         */
3797        SPECIMEN, 
3798        /**
3799         * A kind of specimen with associated set of requirements.
3800         */
3801        SPECIMENDEFINITION, 
3802        /**
3803         * A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.
3804         */
3805        STRUCTUREDEFINITION, 
3806        /**
3807         * A Map of relationships between 2 structures that can be used to transform data.
3808         */
3809        STRUCTUREMAP, 
3810        /**
3811         * The subscription resource is used to define a push-based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined "channel" so that another system can take an appropriate action.
3812         */
3813        SUBSCRIPTION, 
3814        /**
3815         * A homogeneous material with a definite composition.
3816         */
3817        SUBSTANCE, 
3818        /**
3819         * Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction.
3820         */
3821        SUBSTANCENUCLEICACID, 
3822        /**
3823         * Todo.
3824         */
3825        SUBSTANCEPOLYMER, 
3826        /**
3827         * A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators.
3828         */
3829        SUBSTANCEPROTEIN, 
3830        /**
3831         * Todo.
3832         */
3833        SUBSTANCEREFERENCEINFORMATION, 
3834        /**
3835         * Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex.
3836         */
3837        SUBSTANCESOURCEMATERIAL, 
3838        /**
3839         * The detailed description of a substance, typically at a level beyond what is used for prescribing.
3840         */
3841        SUBSTANCESPECIFICATION, 
3842        /**
3843         * Record of delivery of what is supplied.
3844         */
3845        SUPPLYDELIVERY, 
3846        /**
3847         * A record of a request for a medication, substance or device used in the healthcare setting.
3848         */
3849        SUPPLYREQUEST, 
3850        /**
3851         * A task to be performed.
3852         */
3853        TASK, 
3854        /**
3855         * A Terminology Capabilities documents a set of capabilities (behaviors) of a FHIR Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
3856         */
3857        TERMINOLOGYCAPABILITIES, 
3858        /**
3859         * A summary of information based on the results of executing a TestScript.
3860         */
3861        TESTREPORT, 
3862        /**
3863         * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
3864         */
3865        TESTSCRIPT, 
3866        /**
3867         * A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).
3868         */
3869        VALUESET, 
3870        /**
3871         * Describes validation requirements, source(s), status and dates for one or more elements.
3872         */
3873        VERIFICATIONRESULT, 
3874        /**
3875         * An authorization for the provision of glasses and/or contact lenses to a patient.
3876         */
3877        VISIONPRESCRIPTION, 
3878        /**
3879         * A place holder that means any kind of data type
3880         */
3881        TYPE, 
3882        /**
3883         * A place holder that means any kind of resource
3884         */
3885        ANY, 
3886        /**
3887         * added to help the parsers
3888         */
3889        NULL;
3890        public static FHIRAllTypes fromCode(String codeString) throws FHIRException {
3891            if (codeString == null || "".equals(codeString))
3892                return null;
3893        if ("Address".equals(codeString))
3894          return ADDRESS;
3895        if ("Age".equals(codeString))
3896          return AGE;
3897        if ("Annotation".equals(codeString))
3898          return ANNOTATION;
3899        if ("Attachment".equals(codeString))
3900          return ATTACHMENT;
3901        if ("BackboneElement".equals(codeString))
3902          return BACKBONEELEMENT;
3903        if ("CodeableConcept".equals(codeString))
3904          return CODEABLECONCEPT;
3905        if ("Coding".equals(codeString))
3906          return CODING;
3907        if ("ContactDetail".equals(codeString))
3908          return CONTACTDETAIL;
3909        if ("ContactPoint".equals(codeString))
3910          return CONTACTPOINT;
3911        if ("Contributor".equals(codeString))
3912          return CONTRIBUTOR;
3913        if ("Count".equals(codeString))
3914          return COUNT;
3915        if ("DataRequirement".equals(codeString))
3916          return DATAREQUIREMENT;
3917        if ("Distance".equals(codeString))
3918          return DISTANCE;
3919        if ("Dosage".equals(codeString))
3920          return DOSAGE;
3921        if ("Duration".equals(codeString))
3922          return DURATION;
3923        if ("Element".equals(codeString))
3924          return ELEMENT;
3925        if ("ElementDefinition".equals(codeString))
3926          return ELEMENTDEFINITION;
3927        if ("Expression".equals(codeString))
3928          return EXPRESSION;
3929        if ("Extension".equals(codeString))
3930          return EXTENSION;
3931        if ("HumanName".equals(codeString))
3932          return HUMANNAME;
3933        if ("Identifier".equals(codeString))
3934          return IDENTIFIER;
3935        if ("MarketingStatus".equals(codeString))
3936          return MARKETINGSTATUS;
3937        if ("Meta".equals(codeString))
3938          return META;
3939        if ("Money".equals(codeString))
3940          return MONEY;
3941        if ("MoneyQuantity".equals(codeString))
3942          return MONEYQUANTITY;
3943        if ("Narrative".equals(codeString))
3944          return NARRATIVE;
3945        if ("ParameterDefinition".equals(codeString))
3946          return PARAMETERDEFINITION;
3947        if ("Period".equals(codeString))
3948          return PERIOD;
3949        if ("Population".equals(codeString))
3950          return POPULATION;
3951        if ("ProdCharacteristic".equals(codeString))
3952          return PRODCHARACTERISTIC;
3953        if ("ProductShelfLife".equals(codeString))
3954          return PRODUCTSHELFLIFE;
3955        if ("Quantity".equals(codeString))
3956          return QUANTITY;
3957        if ("Range".equals(codeString))
3958          return RANGE;
3959        if ("Ratio".equals(codeString))
3960          return RATIO;
3961        if ("Reference".equals(codeString))
3962          return REFERENCE;
3963        if ("RelatedArtifact".equals(codeString))
3964          return RELATEDARTIFACT;
3965        if ("SampledData".equals(codeString))
3966          return SAMPLEDDATA;
3967        if ("Signature".equals(codeString))
3968          return SIGNATURE;
3969        if ("SimpleQuantity".equals(codeString))
3970          return SIMPLEQUANTITY;
3971        if ("SubstanceAmount".equals(codeString))
3972          return SUBSTANCEAMOUNT;
3973        if ("Timing".equals(codeString))
3974          return TIMING;
3975        if ("TriggerDefinition".equals(codeString))
3976          return TRIGGERDEFINITION;
3977        if ("UsageContext".equals(codeString))
3978          return USAGECONTEXT;
3979        if ("base64Binary".equals(codeString))
3980          return BASE64BINARY;
3981        if ("boolean".equals(codeString))
3982          return BOOLEAN;
3983        if ("canonical".equals(codeString))
3984          return CANONICAL;
3985        if ("code".equals(codeString))
3986          return CODE;
3987        if ("date".equals(codeString))
3988          return DATE;
3989        if ("dateTime".equals(codeString))
3990          return DATETIME;
3991        if ("decimal".equals(codeString))
3992          return DECIMAL;
3993        if ("id".equals(codeString))
3994          return ID;
3995        if ("instant".equals(codeString))
3996          return INSTANT;
3997        if ("integer".equals(codeString))
3998          return INTEGER;
3999        if ("markdown".equals(codeString))
4000          return MARKDOWN;
4001        if ("oid".equals(codeString))
4002          return OID;
4003        if ("positiveInt".equals(codeString))
4004          return POSITIVEINT;
4005        if ("string".equals(codeString))
4006          return STRING;
4007        if ("time".equals(codeString))
4008          return TIME;
4009        if ("unsignedInt".equals(codeString))
4010          return UNSIGNEDINT;
4011        if ("uri".equals(codeString))
4012          return URI;
4013        if ("url".equals(codeString))
4014          return URL;
4015        if ("uuid".equals(codeString))
4016          return UUID;
4017        if ("xhtml".equals(codeString))
4018          return XHTML;
4019        if ("Account".equals(codeString))
4020          return ACCOUNT;
4021        if ("ActivityDefinition".equals(codeString))
4022          return ACTIVITYDEFINITION;
4023        if ("AdverseEvent".equals(codeString))
4024          return ADVERSEEVENT;
4025        if ("AllergyIntolerance".equals(codeString))
4026          return ALLERGYINTOLERANCE;
4027        if ("Appointment".equals(codeString))
4028          return APPOINTMENT;
4029        if ("AppointmentResponse".equals(codeString))
4030          return APPOINTMENTRESPONSE;
4031        if ("AuditEvent".equals(codeString))
4032          return AUDITEVENT;
4033        if ("Basic".equals(codeString))
4034          return BASIC;
4035        if ("Binary".equals(codeString))
4036          return BINARY;
4037        if ("BiologicallyDerivedProduct".equals(codeString))
4038          return BIOLOGICALLYDERIVEDPRODUCT;
4039        if ("BodyStructure".equals(codeString))
4040          return BODYSTRUCTURE;
4041        if ("Bundle".equals(codeString))
4042          return BUNDLE;
4043        if ("CapabilityStatement".equals(codeString))
4044          return CAPABILITYSTATEMENT;
4045        if ("CarePlan".equals(codeString))
4046          return CAREPLAN;
4047        if ("CareTeam".equals(codeString))
4048          return CARETEAM;
4049        if ("CatalogEntry".equals(codeString))
4050          return CATALOGENTRY;
4051        if ("ChargeItem".equals(codeString))
4052          return CHARGEITEM;
4053        if ("ChargeItemDefinition".equals(codeString))
4054          return CHARGEITEMDEFINITION;
4055        if ("Claim".equals(codeString))
4056          return CLAIM;
4057        if ("ClaimResponse".equals(codeString))
4058          return CLAIMRESPONSE;
4059        if ("ClinicalImpression".equals(codeString))
4060          return CLINICALIMPRESSION;
4061        if ("CodeSystem".equals(codeString))
4062          return CODESYSTEM;
4063        if ("Communication".equals(codeString))
4064          return COMMUNICATION;
4065        if ("CommunicationRequest".equals(codeString))
4066          return COMMUNICATIONREQUEST;
4067        if ("CompartmentDefinition".equals(codeString))
4068          return COMPARTMENTDEFINITION;
4069        if ("Composition".equals(codeString))
4070          return COMPOSITION;
4071        if ("ConceptMap".equals(codeString))
4072          return CONCEPTMAP;
4073        if ("Condition".equals(codeString))
4074          return CONDITION;
4075        if ("Consent".equals(codeString))
4076          return CONSENT;
4077        if ("Contract".equals(codeString))
4078          return CONTRACT;
4079        if ("Coverage".equals(codeString))
4080          return COVERAGE;
4081        if ("CoverageEligibilityRequest".equals(codeString))
4082          return COVERAGEELIGIBILITYREQUEST;
4083        if ("CoverageEligibilityResponse".equals(codeString))
4084          return COVERAGEELIGIBILITYRESPONSE;
4085        if ("DetectedIssue".equals(codeString))
4086          return DETECTEDISSUE;
4087        if ("Device".equals(codeString))
4088          return DEVICE;
4089        if ("DeviceDefinition".equals(codeString))
4090          return DEVICEDEFINITION;
4091        if ("DeviceMetric".equals(codeString))
4092          return DEVICEMETRIC;
4093        if ("DeviceRequest".equals(codeString))
4094          return DEVICEREQUEST;
4095        if ("DeviceUseStatement".equals(codeString))
4096          return DEVICEUSESTATEMENT;
4097        if ("DiagnosticReport".equals(codeString))
4098          return DIAGNOSTICREPORT;
4099        if ("DocumentManifest".equals(codeString))
4100          return DOCUMENTMANIFEST;
4101        if ("DocumentReference".equals(codeString))
4102          return DOCUMENTREFERENCE;
4103        if ("DomainResource".equals(codeString))
4104          return DOMAINRESOURCE;
4105        if ("EffectEvidenceSynthesis".equals(codeString))
4106          return EFFECTEVIDENCESYNTHESIS;
4107        if ("Encounter".equals(codeString))
4108          return ENCOUNTER;
4109        if ("Endpoint".equals(codeString))
4110          return ENDPOINT;
4111        if ("EnrollmentRequest".equals(codeString))
4112          return ENROLLMENTREQUEST;
4113        if ("EnrollmentResponse".equals(codeString))
4114          return ENROLLMENTRESPONSE;
4115        if ("EpisodeOfCare".equals(codeString))
4116          return EPISODEOFCARE;
4117        if ("EventDefinition".equals(codeString))
4118          return EVENTDEFINITION;
4119        if ("Evidence".equals(codeString))
4120          return EVIDENCE;
4121        if ("EvidenceVariable".equals(codeString))
4122          return EVIDENCEVARIABLE;
4123        if ("ExampleScenario".equals(codeString))
4124          return EXAMPLESCENARIO;
4125        if ("ExplanationOfBenefit".equals(codeString))
4126          return EXPLANATIONOFBENEFIT;
4127        if ("FamilyMemberHistory".equals(codeString))
4128          return FAMILYMEMBERHISTORY;
4129        if ("Flag".equals(codeString))
4130          return FLAG;
4131        if ("Goal".equals(codeString))
4132          return GOAL;
4133        if ("GraphDefinition".equals(codeString))
4134          return GRAPHDEFINITION;
4135        if ("Group".equals(codeString))
4136          return GROUP;
4137        if ("GuidanceResponse".equals(codeString))
4138          return GUIDANCERESPONSE;
4139        if ("HealthcareService".equals(codeString))
4140          return HEALTHCARESERVICE;
4141        if ("ImagingStudy".equals(codeString))
4142          return IMAGINGSTUDY;
4143        if ("Immunization".equals(codeString))
4144          return IMMUNIZATION;
4145        if ("ImmunizationEvaluation".equals(codeString))
4146          return IMMUNIZATIONEVALUATION;
4147        if ("ImmunizationRecommendation".equals(codeString))
4148          return IMMUNIZATIONRECOMMENDATION;
4149        if ("ImplementationGuide".equals(codeString))
4150          return IMPLEMENTATIONGUIDE;
4151        if ("InsurancePlan".equals(codeString))
4152          return INSURANCEPLAN;
4153        if ("Invoice".equals(codeString))
4154          return INVOICE;
4155        if ("Library".equals(codeString))
4156          return LIBRARY;
4157        if ("Linkage".equals(codeString))
4158          return LINKAGE;
4159        if ("List".equals(codeString))
4160          return LIST;
4161        if ("Location".equals(codeString))
4162          return LOCATION;
4163        if ("Measure".equals(codeString))
4164          return MEASURE;
4165        if ("MeasureReport".equals(codeString))
4166          return MEASUREREPORT;
4167        if ("Media".equals(codeString))
4168          return MEDIA;
4169        if ("Medication".equals(codeString))
4170          return MEDICATION;
4171        if ("MedicationAdministration".equals(codeString))
4172          return MEDICATIONADMINISTRATION;
4173        if ("MedicationDispense".equals(codeString))
4174          return MEDICATIONDISPENSE;
4175        if ("MedicationKnowledge".equals(codeString))
4176          return MEDICATIONKNOWLEDGE;
4177        if ("MedicationRequest".equals(codeString))
4178          return MEDICATIONREQUEST;
4179        if ("MedicationStatement".equals(codeString))
4180          return MEDICATIONSTATEMENT;
4181        if ("MedicinalProduct".equals(codeString))
4182          return MEDICINALPRODUCT;
4183        if ("MedicinalProductAuthorization".equals(codeString))
4184          return MEDICINALPRODUCTAUTHORIZATION;
4185        if ("MedicinalProductContraindication".equals(codeString))
4186          return MEDICINALPRODUCTCONTRAINDICATION;
4187        if ("MedicinalProductIndication".equals(codeString))
4188          return MEDICINALPRODUCTINDICATION;
4189        if ("MedicinalProductIngredient".equals(codeString))
4190          return MEDICINALPRODUCTINGREDIENT;
4191        if ("MedicinalProductInteraction".equals(codeString))
4192          return MEDICINALPRODUCTINTERACTION;
4193        if ("MedicinalProductManufactured".equals(codeString))
4194          return MEDICINALPRODUCTMANUFACTURED;
4195        if ("MedicinalProductPackaged".equals(codeString))
4196          return MEDICINALPRODUCTPACKAGED;
4197        if ("MedicinalProductPharmaceutical".equals(codeString))
4198          return MEDICINALPRODUCTPHARMACEUTICAL;
4199        if ("MedicinalProductUndesirableEffect".equals(codeString))
4200          return MEDICINALPRODUCTUNDESIRABLEEFFECT;
4201        if ("MessageDefinition".equals(codeString))
4202          return MESSAGEDEFINITION;
4203        if ("MessageHeader".equals(codeString))
4204          return MESSAGEHEADER;
4205        if ("MolecularSequence".equals(codeString))
4206          return MOLECULARSEQUENCE;
4207        if ("NamingSystem".equals(codeString))
4208          return NAMINGSYSTEM;
4209        if ("NutritionOrder".equals(codeString))
4210          return NUTRITIONORDER;
4211        if ("Observation".equals(codeString))
4212          return OBSERVATION;
4213        if ("ObservationDefinition".equals(codeString))
4214          return OBSERVATIONDEFINITION;
4215        if ("OperationDefinition".equals(codeString))
4216          return OPERATIONDEFINITION;
4217        if ("OperationOutcome".equals(codeString))
4218          return OPERATIONOUTCOME;
4219        if ("Organization".equals(codeString))
4220          return ORGANIZATION;
4221        if ("OrganizationAffiliation".equals(codeString))
4222          return ORGANIZATIONAFFILIATION;
4223        if ("Parameters".equals(codeString))
4224          return PARAMETERS;
4225        if ("Patient".equals(codeString))
4226          return PATIENT;
4227        if ("PaymentNotice".equals(codeString))
4228          return PAYMENTNOTICE;
4229        if ("PaymentReconciliation".equals(codeString))
4230          return PAYMENTRECONCILIATION;
4231        if ("Person".equals(codeString))
4232          return PERSON;
4233        if ("PlanDefinition".equals(codeString))
4234          return PLANDEFINITION;
4235        if ("Practitioner".equals(codeString))
4236          return PRACTITIONER;
4237        if ("PractitionerRole".equals(codeString))
4238          return PRACTITIONERROLE;
4239        if ("Procedure".equals(codeString))
4240          return PROCEDURE;
4241        if ("Provenance".equals(codeString))
4242          return PROVENANCE;
4243        if ("Questionnaire".equals(codeString))
4244          return QUESTIONNAIRE;
4245        if ("QuestionnaireResponse".equals(codeString))
4246          return QUESTIONNAIRERESPONSE;
4247        if ("RelatedPerson".equals(codeString))
4248          return RELATEDPERSON;
4249        if ("RequestGroup".equals(codeString))
4250          return REQUESTGROUP;
4251        if ("ResearchDefinition".equals(codeString))
4252          return RESEARCHDEFINITION;
4253        if ("ResearchElementDefinition".equals(codeString))
4254          return RESEARCHELEMENTDEFINITION;
4255        if ("ResearchStudy".equals(codeString))
4256          return RESEARCHSTUDY;
4257        if ("ResearchSubject".equals(codeString))
4258          return RESEARCHSUBJECT;
4259        if ("Resource".equals(codeString))
4260          return RESOURCE;
4261        if ("RiskAssessment".equals(codeString))
4262          return RISKASSESSMENT;
4263        if ("RiskEvidenceSynthesis".equals(codeString))
4264          return RISKEVIDENCESYNTHESIS;
4265        if ("Schedule".equals(codeString))
4266          return SCHEDULE;
4267        if ("SearchParameter".equals(codeString))
4268          return SEARCHPARAMETER;
4269        if ("ServiceRequest".equals(codeString))
4270          return SERVICEREQUEST;
4271        if ("Slot".equals(codeString))
4272          return SLOT;
4273        if ("Specimen".equals(codeString))
4274          return SPECIMEN;
4275        if ("SpecimenDefinition".equals(codeString))
4276          return SPECIMENDEFINITION;
4277        if ("StructureDefinition".equals(codeString))
4278          return STRUCTUREDEFINITION;
4279        if ("StructureMap".equals(codeString))
4280          return STRUCTUREMAP;
4281        if ("Subscription".equals(codeString))
4282          return SUBSCRIPTION;
4283        if ("Substance".equals(codeString))
4284          return SUBSTANCE;
4285        if ("SubstanceNucleicAcid".equals(codeString))
4286          return SUBSTANCENUCLEICACID;
4287        if ("SubstancePolymer".equals(codeString))
4288          return SUBSTANCEPOLYMER;
4289        if ("SubstanceProtein".equals(codeString))
4290          return SUBSTANCEPROTEIN;
4291        if ("SubstanceReferenceInformation".equals(codeString))
4292          return SUBSTANCEREFERENCEINFORMATION;
4293        if ("SubstanceSourceMaterial".equals(codeString))
4294          return SUBSTANCESOURCEMATERIAL;
4295        if ("SubstanceSpecification".equals(codeString))
4296          return SUBSTANCESPECIFICATION;
4297        if ("SupplyDelivery".equals(codeString))
4298          return SUPPLYDELIVERY;
4299        if ("SupplyRequest".equals(codeString))
4300          return SUPPLYREQUEST;
4301        if ("Task".equals(codeString))
4302          return TASK;
4303        if ("TerminologyCapabilities".equals(codeString))
4304          return TERMINOLOGYCAPABILITIES;
4305        if ("TestReport".equals(codeString))
4306          return TESTREPORT;
4307        if ("TestScript".equals(codeString))
4308          return TESTSCRIPT;
4309        if ("ValueSet".equals(codeString))
4310          return VALUESET;
4311        if ("VerificationResult".equals(codeString))
4312          return VERIFICATIONRESULT;
4313        if ("VisionPrescription".equals(codeString))
4314          return VISIONPRESCRIPTION;
4315        if ("Type".equals(codeString))
4316          return TYPE;
4317        if ("Any".equals(codeString))
4318          return ANY;
4319        throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'");
4320        }
4321        public String toCode() {
4322          switch (this) {
4323            case ADDRESS: return "Address";
4324            case AGE: return "Age";
4325            case ANNOTATION: return "Annotation";
4326            case ATTACHMENT: return "Attachment";
4327            case BACKBONEELEMENT: return "BackboneElement";
4328            case CODEABLECONCEPT: return "CodeableConcept";
4329            case CODING: return "Coding";
4330            case CONTACTDETAIL: return "ContactDetail";
4331            case CONTACTPOINT: return "ContactPoint";
4332            case CONTRIBUTOR: return "Contributor";
4333            case COUNT: return "Count";
4334            case DATAREQUIREMENT: return "DataRequirement";
4335            case DISTANCE: return "Distance";
4336            case DOSAGE: return "Dosage";
4337            case DURATION: return "Duration";
4338            case ELEMENT: return "Element";
4339            case ELEMENTDEFINITION: return "ElementDefinition";
4340            case EXPRESSION: return "Expression";
4341            case EXTENSION: return "Extension";
4342            case HUMANNAME: return "HumanName";
4343            case IDENTIFIER: return "Identifier";
4344            case MARKETINGSTATUS: return "MarketingStatus";
4345            case META: return "Meta";
4346            case MONEY: return "Money";
4347            case MONEYQUANTITY: return "MoneyQuantity";
4348            case NARRATIVE: return "Narrative";
4349            case PARAMETERDEFINITION: return "ParameterDefinition";
4350            case PERIOD: return "Period";
4351            case POPULATION: return "Population";
4352            case PRODCHARACTERISTIC: return "ProdCharacteristic";
4353            case PRODUCTSHELFLIFE: return "ProductShelfLife";
4354            case QUANTITY: return "Quantity";
4355            case RANGE: return "Range";
4356            case RATIO: return "Ratio";
4357            case REFERENCE: return "Reference";
4358            case RELATEDARTIFACT: return "RelatedArtifact";
4359            case SAMPLEDDATA: return "SampledData";
4360            case SIGNATURE: return "Signature";
4361            case SIMPLEQUANTITY: return "SimpleQuantity";
4362            case SUBSTANCEAMOUNT: return "SubstanceAmount";
4363            case TIMING: return "Timing";
4364            case TRIGGERDEFINITION: return "TriggerDefinition";
4365            case USAGECONTEXT: return "UsageContext";
4366            case BASE64BINARY: return "base64Binary";
4367            case BOOLEAN: return "boolean";
4368            case CANONICAL: return "canonical";
4369            case CODE: return "code";
4370            case DATE: return "date";
4371            case DATETIME: return "dateTime";
4372            case DECIMAL: return "decimal";
4373            case ID: return "id";
4374            case INSTANT: return "instant";
4375            case INTEGER: return "integer";
4376            case MARKDOWN: return "markdown";
4377            case OID: return "oid";
4378            case POSITIVEINT: return "positiveInt";
4379            case STRING: return "string";
4380            case TIME: return "time";
4381            case UNSIGNEDINT: return "unsignedInt";
4382            case URI: return "uri";
4383            case URL: return "url";
4384            case UUID: return "uuid";
4385            case XHTML: return "xhtml";
4386            case ACCOUNT: return "Account";
4387            case ACTIVITYDEFINITION: return "ActivityDefinition";
4388            case ADVERSEEVENT: return "AdverseEvent";
4389            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
4390            case APPOINTMENT: return "Appointment";
4391            case APPOINTMENTRESPONSE: return "AppointmentResponse";
4392            case AUDITEVENT: return "AuditEvent";
4393            case BASIC: return "Basic";
4394            case BINARY: return "Binary";
4395            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
4396            case BODYSTRUCTURE: return "BodyStructure";
4397            case BUNDLE: return "Bundle";
4398            case CAPABILITYSTATEMENT: return "CapabilityStatement";
4399            case CAREPLAN: return "CarePlan";
4400            case CARETEAM: return "CareTeam";
4401            case CATALOGENTRY: return "CatalogEntry";
4402            case CHARGEITEM: return "ChargeItem";
4403            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
4404            case CLAIM: return "Claim";
4405            case CLAIMRESPONSE: return "ClaimResponse";
4406            case CLINICALIMPRESSION: return "ClinicalImpression";
4407            case CODESYSTEM: return "CodeSystem";
4408            case COMMUNICATION: return "Communication";
4409            case COMMUNICATIONREQUEST: return "CommunicationRequest";
4410            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
4411            case COMPOSITION: return "Composition";
4412            case CONCEPTMAP: return "ConceptMap";
4413            case CONDITION: return "Condition";
4414            case CONSENT: return "Consent";
4415            case CONTRACT: return "Contract";
4416            case COVERAGE: return "Coverage";
4417            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
4418            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
4419            case DETECTEDISSUE: return "DetectedIssue";
4420            case DEVICE: return "Device";
4421            case DEVICEDEFINITION: return "DeviceDefinition";
4422            case DEVICEMETRIC: return "DeviceMetric";
4423            case DEVICEREQUEST: return "DeviceRequest";
4424            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
4425            case DIAGNOSTICREPORT: return "DiagnosticReport";
4426            case DOCUMENTMANIFEST: return "DocumentManifest";
4427            case DOCUMENTREFERENCE: return "DocumentReference";
4428            case DOMAINRESOURCE: return "DomainResource";
4429            case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis";
4430            case ENCOUNTER: return "Encounter";
4431            case ENDPOINT: return "Endpoint";
4432            case ENROLLMENTREQUEST: return "EnrollmentRequest";
4433            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
4434            case EPISODEOFCARE: return "EpisodeOfCare";
4435            case EVENTDEFINITION: return "EventDefinition";
4436            case EVIDENCE: return "Evidence";
4437            case EVIDENCEVARIABLE: return "EvidenceVariable";
4438            case EXAMPLESCENARIO: return "ExampleScenario";
4439            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
4440            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
4441            case FLAG: return "Flag";
4442            case GOAL: return "Goal";
4443            case GRAPHDEFINITION: return "GraphDefinition";
4444            case GROUP: return "Group";
4445            case GUIDANCERESPONSE: return "GuidanceResponse";
4446            case HEALTHCARESERVICE: return "HealthcareService";
4447            case IMAGINGSTUDY: return "ImagingStudy";
4448            case IMMUNIZATION: return "Immunization";
4449            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
4450            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
4451            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
4452            case INSURANCEPLAN: return "InsurancePlan";
4453            case INVOICE: return "Invoice";
4454            case LIBRARY: return "Library";
4455            case LINKAGE: return "Linkage";
4456            case LIST: return "List";
4457            case LOCATION: return "Location";
4458            case MEASURE: return "Measure";
4459            case MEASUREREPORT: return "MeasureReport";
4460            case MEDIA: return "Media";
4461            case MEDICATION: return "Medication";
4462            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
4463            case MEDICATIONDISPENSE: return "MedicationDispense";
4464            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
4465            case MEDICATIONREQUEST: return "MedicationRequest";
4466            case MEDICATIONSTATEMENT: return "MedicationStatement";
4467            case MEDICINALPRODUCT: return "MedicinalProduct";
4468            case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization";
4469            case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication";
4470            case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication";
4471            case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient";
4472            case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction";
4473            case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured";
4474            case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged";
4475            case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical";
4476            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect";
4477            case MESSAGEDEFINITION: return "MessageDefinition";
4478            case MESSAGEHEADER: return "MessageHeader";
4479            case MOLECULARSEQUENCE: return "MolecularSequence";
4480            case NAMINGSYSTEM: return "NamingSystem";
4481            case NUTRITIONORDER: return "NutritionOrder";
4482            case OBSERVATION: return "Observation";
4483            case OBSERVATIONDEFINITION: return "ObservationDefinition";
4484            case OPERATIONDEFINITION: return "OperationDefinition";
4485            case OPERATIONOUTCOME: return "OperationOutcome";
4486            case ORGANIZATION: return "Organization";
4487            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
4488            case PARAMETERS: return "Parameters";
4489            case PATIENT: return "Patient";
4490            case PAYMENTNOTICE: return "PaymentNotice";
4491            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
4492            case PERSON: return "Person";
4493            case PLANDEFINITION: return "PlanDefinition";
4494            case PRACTITIONER: return "Practitioner";
4495            case PRACTITIONERROLE: return "PractitionerRole";
4496            case PROCEDURE: return "Procedure";
4497            case PROVENANCE: return "Provenance";
4498            case QUESTIONNAIRE: return "Questionnaire";
4499            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
4500            case RELATEDPERSON: return "RelatedPerson";
4501            case REQUESTGROUP: return "RequestGroup";
4502            case RESEARCHDEFINITION: return "ResearchDefinition";
4503            case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition";
4504            case RESEARCHSTUDY: return "ResearchStudy";
4505            case RESEARCHSUBJECT: return "ResearchSubject";
4506            case RESOURCE: return "Resource";
4507            case RISKASSESSMENT: return "RiskAssessment";
4508            case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis";
4509            case SCHEDULE: return "Schedule";
4510            case SEARCHPARAMETER: return "SearchParameter";
4511            case SERVICEREQUEST: return "ServiceRequest";
4512            case SLOT: return "Slot";
4513            case SPECIMEN: return "Specimen";
4514            case SPECIMENDEFINITION: return "SpecimenDefinition";
4515            case STRUCTUREDEFINITION: return "StructureDefinition";
4516            case STRUCTUREMAP: return "StructureMap";
4517            case SUBSCRIPTION: return "Subscription";
4518            case SUBSTANCE: return "Substance";
4519            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
4520            case SUBSTANCEPOLYMER: return "SubstancePolymer";
4521            case SUBSTANCEPROTEIN: return "SubstanceProtein";
4522            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
4523            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
4524            case SUBSTANCESPECIFICATION: return "SubstanceSpecification";
4525            case SUPPLYDELIVERY: return "SupplyDelivery";
4526            case SUPPLYREQUEST: return "SupplyRequest";
4527            case TASK: return "Task";
4528            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
4529            case TESTREPORT: return "TestReport";
4530            case TESTSCRIPT: return "TestScript";
4531            case VALUESET: return "ValueSet";
4532            case VERIFICATIONRESULT: return "VerificationResult";
4533            case VISIONPRESCRIPTION: return "VisionPrescription";
4534            case TYPE: return "Type";
4535            case ANY: return "Any";
4536            case NULL: return null;
4537            default: return "?";
4538          }
4539        }
4540        public String getSystem() {
4541          switch (this) {
4542            case ADDRESS: return "http://hl7.org/fhir/data-types";
4543            case AGE: return "http://hl7.org/fhir/data-types";
4544            case ANNOTATION: return "http://hl7.org/fhir/data-types";
4545            case ATTACHMENT: return "http://hl7.org/fhir/data-types";
4546            case BACKBONEELEMENT: return "http://hl7.org/fhir/data-types";
4547            case CODEABLECONCEPT: return "http://hl7.org/fhir/data-types";
4548            case CODING: return "http://hl7.org/fhir/data-types";
4549            case CONTACTDETAIL: return "http://hl7.org/fhir/data-types";
4550            case CONTACTPOINT: return "http://hl7.org/fhir/data-types";
4551            case CONTRIBUTOR: return "http://hl7.org/fhir/data-types";
4552            case COUNT: return "http://hl7.org/fhir/data-types";
4553            case DATAREQUIREMENT: return "http://hl7.org/fhir/data-types";
4554            case DISTANCE: return "http://hl7.org/fhir/data-types";
4555            case DOSAGE: return "http://hl7.org/fhir/data-types";
4556            case DURATION: return "http://hl7.org/fhir/data-types";
4557            case ELEMENT: return "http://hl7.org/fhir/data-types";
4558            case ELEMENTDEFINITION: return "http://hl7.org/fhir/data-types";
4559            case EXPRESSION: return "http://hl7.org/fhir/data-types";
4560            case EXTENSION: return "http://hl7.org/fhir/data-types";
4561            case HUMANNAME: return "http://hl7.org/fhir/data-types";
4562            case IDENTIFIER: return "http://hl7.org/fhir/data-types";
4563            case MARKETINGSTATUS: return "http://hl7.org/fhir/data-types";
4564            case META: return "http://hl7.org/fhir/data-types";
4565            case MONEY: return "http://hl7.org/fhir/data-types";
4566            case MONEYQUANTITY: return "http://hl7.org/fhir/data-types";
4567            case NARRATIVE: return "http://hl7.org/fhir/data-types";
4568            case PARAMETERDEFINITION: return "http://hl7.org/fhir/data-types";
4569            case PERIOD: return "http://hl7.org/fhir/data-types";
4570            case POPULATION: return "http://hl7.org/fhir/data-types";
4571            case PRODCHARACTERISTIC: return "http://hl7.org/fhir/data-types";
4572            case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/data-types";
4573            case QUANTITY: return "http://hl7.org/fhir/data-types";
4574            case RANGE: return "http://hl7.org/fhir/data-types";
4575            case RATIO: return "http://hl7.org/fhir/data-types";
4576            case REFERENCE: return "http://hl7.org/fhir/data-types";
4577            case RELATEDARTIFACT: return "http://hl7.org/fhir/data-types";
4578            case SAMPLEDDATA: return "http://hl7.org/fhir/data-types";
4579            case SIGNATURE: return "http://hl7.org/fhir/data-types";
4580            case SIMPLEQUANTITY: return "http://hl7.org/fhir/data-types";
4581            case SUBSTANCEAMOUNT: return "http://hl7.org/fhir/data-types";
4582            case TIMING: return "http://hl7.org/fhir/data-types";
4583            case TRIGGERDEFINITION: return "http://hl7.org/fhir/data-types";
4584            case USAGECONTEXT: return "http://hl7.org/fhir/data-types";
4585            case BASE64BINARY: return "http://hl7.org/fhir/data-types";
4586            case BOOLEAN: return "http://hl7.org/fhir/data-types";
4587            case CANONICAL: return "http://hl7.org/fhir/data-types";
4588            case CODE: return "http://hl7.org/fhir/data-types";
4589            case DATE: return "http://hl7.org/fhir/data-types";
4590            case DATETIME: return "http://hl7.org/fhir/data-types";
4591            case DECIMAL: return "http://hl7.org/fhir/data-types";
4592            case ID: return "http://hl7.org/fhir/data-types";
4593            case INSTANT: return "http://hl7.org/fhir/data-types";
4594            case INTEGER: return "http://hl7.org/fhir/data-types";
4595            case MARKDOWN: return "http://hl7.org/fhir/data-types";
4596            case OID: return "http://hl7.org/fhir/data-types";
4597            case POSITIVEINT: return "http://hl7.org/fhir/data-types";
4598            case STRING: return "http://hl7.org/fhir/data-types";
4599            case TIME: return "http://hl7.org/fhir/data-types";
4600            case UNSIGNEDINT: return "http://hl7.org/fhir/data-types";
4601            case URI: return "http://hl7.org/fhir/data-types";
4602            case URL: return "http://hl7.org/fhir/data-types";
4603            case UUID: return "http://hl7.org/fhir/data-types";
4604            case XHTML: return "http://hl7.org/fhir/data-types";
4605            case ACCOUNT: return "http://hl7.org/fhir/resource-types";
4606            case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types";
4607            case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types";
4608            case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types";
4609            case APPOINTMENT: return "http://hl7.org/fhir/resource-types";
4610            case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
4611            case AUDITEVENT: return "http://hl7.org/fhir/resource-types";
4612            case BASIC: return "http://hl7.org/fhir/resource-types";
4613            case BINARY: return "http://hl7.org/fhir/resource-types";
4614            case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types";
4615            case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types";
4616            case BUNDLE: return "http://hl7.org/fhir/resource-types";
4617            case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types";
4618            case CAREPLAN: return "http://hl7.org/fhir/resource-types";
4619            case CARETEAM: return "http://hl7.org/fhir/resource-types";
4620            case CATALOGENTRY: return "http://hl7.org/fhir/resource-types";
4621            case CHARGEITEM: return "http://hl7.org/fhir/resource-types";
4622            case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
4623            case CLAIM: return "http://hl7.org/fhir/resource-types";
4624            case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types";
4625            case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types";
4626            case CODESYSTEM: return "http://hl7.org/fhir/resource-types";
4627            case COMMUNICATION: return "http://hl7.org/fhir/resource-types";
4628            case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
4629            case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
4630            case COMPOSITION: return "http://hl7.org/fhir/resource-types";
4631            case CONCEPTMAP: return "http://hl7.org/fhir/resource-types";
4632            case CONDITION: return "http://hl7.org/fhir/resource-types";
4633            case CONSENT: return "http://hl7.org/fhir/resource-types";
4634            case CONTRACT: return "http://hl7.org/fhir/resource-types";
4635            case COVERAGE: return "http://hl7.org/fhir/resource-types";
4636            case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types";
4637            case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types";
4638            case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types";
4639            case DEVICE: return "http://hl7.org/fhir/resource-types";
4640            case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types";
4641            case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types";
4642            case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types";
4643            case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types";
4644            case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types";
4645            case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types";
4646            case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types";
4647            case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types";
4648            case EFFECTEVIDENCESYNTHESIS: return "http://hl7.org/fhir/resource-types";
4649            case ENCOUNTER: return "http://hl7.org/fhir/resource-types";
4650            case ENDPOINT: return "http://hl7.org/fhir/resource-types";
4651            case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types";
4652            case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
4653            case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types";
4654            case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types";
4655            case EVIDENCE: return "http://hl7.org/fhir/resource-types";
4656            case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types";
4657            case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types";
4658            case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types";
4659            case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types";
4660            case FLAG: return "http://hl7.org/fhir/resource-types";
4661            case GOAL: return "http://hl7.org/fhir/resource-types";
4662            case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types";
4663            case GROUP: return "http://hl7.org/fhir/resource-types";
4664            case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types";
4665            case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types";
4666            case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types";
4667            case IMMUNIZATION: return "http://hl7.org/fhir/resource-types";
4668            case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types";
4669            case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types";
4670            case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types";
4671            case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types";
4672            case INVOICE: return "http://hl7.org/fhir/resource-types";
4673            case LIBRARY: return "http://hl7.org/fhir/resource-types";
4674            case LINKAGE: return "http://hl7.org/fhir/resource-types";
4675            case LIST: return "http://hl7.org/fhir/resource-types";
4676            case LOCATION: return "http://hl7.org/fhir/resource-types";
4677            case MEASURE: return "http://hl7.org/fhir/resource-types";
4678            case MEASUREREPORT: return "http://hl7.org/fhir/resource-types";
4679            case MEDIA: return "http://hl7.org/fhir/resource-types";
4680            case MEDICATION: return "http://hl7.org/fhir/resource-types";
4681            case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types";
4682            case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types";
4683            case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types";
4684            case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
4685            case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/resource-types";
4686            case MEDICINALPRODUCT: return "http://hl7.org/fhir/resource-types";
4687            case MEDICINALPRODUCTAUTHORIZATION: return "http://hl7.org/fhir/resource-types";
4688            case MEDICINALPRODUCTCONTRAINDICATION: return "http://hl7.org/fhir/resource-types";
4689            case MEDICINALPRODUCTINDICATION: return "http://hl7.org/fhir/resource-types";
4690            case MEDICINALPRODUCTINGREDIENT: return "http://hl7.org/fhir/resource-types";
4691            case MEDICINALPRODUCTINTERACTION: return "http://hl7.org/fhir/resource-types";
4692            case MEDICINALPRODUCTMANUFACTURED: return "http://hl7.org/fhir/resource-types";
4693            case MEDICINALPRODUCTPACKAGED: return "http://hl7.org/fhir/resource-types";
4694            case MEDICINALPRODUCTPHARMACEUTICAL: return "http://hl7.org/fhir/resource-types";
4695            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "http://hl7.org/fhir/resource-types";
4696            case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types";
4697            case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types";
4698            case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types";
4699            case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types";
4700            case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types";
4701            case OBSERVATION: return "http://hl7.org/fhir/resource-types";
4702            case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
4703            case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
4704            case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types";
4705            case ORGANIZATION: return "http://hl7.org/fhir/resource-types";
4706            case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types";
4707            case PARAMETERS: return "http://hl7.org/fhir/resource-types";
4708            case PATIENT: return "http://hl7.org/fhir/resource-types";
4709            case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types";
4710            case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types";
4711            case PERSON: return "http://hl7.org/fhir/resource-types";
4712            case PLANDEFINITION: return "http://hl7.org/fhir/resource-types";
4713            case PRACTITIONER: return "http://hl7.org/fhir/resource-types";
4714            case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types";
4715            case PROCEDURE: return "http://hl7.org/fhir/resource-types";
4716            case PROVENANCE: return "http://hl7.org/fhir/resource-types";
4717            case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types";
4718            case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types";
4719            case RELATEDPERSON: return "http://hl7.org/fhir/resource-types";
4720            case REQUESTGROUP: return "http://hl7.org/fhir/resource-types";
4721            case RESEARCHDEFINITION: return "http://hl7.org/fhir/resource-types";
4722            case RESEARCHELEMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
4723            case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types";
4724            case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types";
4725            case RESOURCE: return "http://hl7.org/fhir/resource-types";
4726            case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types";
4727            case RISKEVIDENCESYNTHESIS: return "http://hl7.org/fhir/resource-types";
4728            case SCHEDULE: return "http://hl7.org/fhir/resource-types";
4729            case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types";
4730            case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types";
4731            case SLOT: return "http://hl7.org/fhir/resource-types";
4732            case SPECIMEN: return "http://hl7.org/fhir/resource-types";
4733            case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types";
4734            case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types";
4735            case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types";
4736            case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types";
4737            case SUBSTANCE: return "http://hl7.org/fhir/resource-types";
4738            case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types";
4739            case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types";
4740            case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types";
4741            case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types";
4742            case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types";
4743            case SUBSTANCESPECIFICATION: return "http://hl7.org/fhir/resource-types";
4744            case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types";
4745            case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types";
4746            case TASK: return "http://hl7.org/fhir/resource-types";
4747            case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types";
4748            case TESTREPORT: return "http://hl7.org/fhir/resource-types";
4749            case TESTSCRIPT: return "http://hl7.org/fhir/resource-types";
4750            case VALUESET: return "http://hl7.org/fhir/resource-types";
4751            case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types";
4752            case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types";
4753            case TYPE: return "http://hl7.org/fhir/abstract-types";
4754            case ANY: return "http://hl7.org/fhir/abstract-types";
4755            case NULL: return null;
4756            default: return "?";
4757          }
4758        }
4759        public String getDefinition() {
4760          switch (this) {
4761            case ADDRESS: return "An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.";
4762            case AGE: return "A duration of time during which an organism (or a process) has existed.";
4763            case ANNOTATION: return "A  text note which also  contains information about who made the statement and when.";
4764            case ATTACHMENT: return "For referring to data content defined in other formats.";
4765            case BACKBONEELEMENT: return "Base definition for all elements that are defined inside a resource - but not those in a data type.";
4766            case CODEABLECONCEPT: return "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.";
4767            case CODING: return "A reference to a code defined by a terminology system.";
4768            case CONTACTDETAIL: return "Specifies contact information for a person or organization.";
4769            case CONTACTPOINT: return "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.";
4770            case CONTRIBUTOR: return "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.";
4771            case COUNT: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
4772            case DATAREQUIREMENT: return "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.";
4773            case DISTANCE: return "A length - a value with a unit that is a physical distance.";
4774            case DOSAGE: return "Indicates how the medication is/was taken or should be taken by the patient.";
4775            case DURATION: return "A length of time.";
4776            case ELEMENT: return "Base definition for all elements in a resource.";
4777            case ELEMENTDEFINITION: return "Captures constraints on each element within the resource, profile, or extension.";
4778            case EXPRESSION: return "A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.";
4779            case EXTENSION: return "Optional Extension Element - found in all resources.";
4780            case HUMANNAME: return "A human's name with the ability to identify parts and usage.";
4781            case IDENTIFIER: return "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.";
4782            case MARKETINGSTATUS: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
4783            case META: return "The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.";
4784            case MONEY: return "An amount of economic utility in some recognized currency.";
4785            case MONEYQUANTITY: return "";
4786            case NARRATIVE: return "A human-readable summary of the resource conveying the essential clinical and business information for the resource.";
4787            case PARAMETERDEFINITION: return "The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.";
4788            case PERIOD: return "A time period defined by a start and end date and optionally time.";
4789            case POPULATION: return "A populatioof people with some set of grouping criteria.";
4790            case PRODCHARACTERISTIC: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
4791            case PRODUCTSHELFLIFE: return "The shelf-life and storage information for a medicinal product item or container can be described using this class.";
4792            case QUANTITY: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
4793            case RANGE: return "A set of ordered Quantities defined by a low and high limit.";
4794            case RATIO: return "A relationship of two Quantity values - expressed as a numerator and a denominator.";
4795            case REFERENCE: return "A reference from one resource to another.";
4796            case RELATEDARTIFACT: return "Related artifacts such as additional documentation, justification, or bibliographic references.";
4797            case SAMPLEDDATA: return "A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.";
4798            case SIGNATURE: return "A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.";
4799            case SIMPLEQUANTITY: return "";
4800            case SUBSTANCEAMOUNT: return "Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.";
4801            case TIMING: return "Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.";
4802            case TRIGGERDEFINITION: return "A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.";
4803            case USAGECONTEXT: return "Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).";
4804            case BASE64BINARY: return "A stream of bytes";
4805            case BOOLEAN: return "Value of \"true\" or \"false\"";
4806            case CANONICAL: return "A URI that is a reference to a canonical URL on a FHIR resource";
4807            case CODE: return "A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents";
4808            case DATE: return "A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.";
4809            case DATETIME: return "A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.";
4810            case DECIMAL: return "A rational number with implicit precision";
4811            case ID: return "Any combination of letters, numerals, \"-\" and \".\", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.";
4812            case INSTANT: return "An instant in time - known at least to the second";
4813            case INTEGER: return "A whole number";
4814            case MARKDOWN: return "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine";
4815            case OID: return "An OID represented as a URI";
4816            case POSITIVEINT: return "An integer with a value that is positive (e.g. >0)";
4817            case STRING: return "A sequence of Unicode characters";
4818            case TIME: return "A time during the day, with no date specified";
4819            case UNSIGNEDINT: return "An integer with a value that is not negative (e.g. >= 0)";
4820            case URI: return "String of characters used to identify a name or a resource";
4821            case URL: return "A URI that is a literal reference";
4822            case UUID: return "A UUID, represented as a URI";
4823            case XHTML: return "XHTML format, as defined by W3C, but restricted usage (mainly, no active content)";
4824            case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose.  In the healthcare field, used to track charges for a patient, cost centers, etc.";
4825            case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.";
4826            case ADVERSEEVENT: return "Actual or  potential/avoided event causing unintended physical injury resulting from or contributed to by medical care, a research study or other healthcare setting factors that requires additional monitoring, treatment, or hospitalization, or that results in death.";
4827            case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.";
4828            case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s).";
4829            case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.";
4830            case AUDITEVENT: return "A record of an event made for purposes of maintaining a security log. Typical uses include detection of intrusion attempts and monitoring for inappropriate usage.";
4831            case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification.";
4832            case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format.  A Binary resource can contain any content, whether text, image, pdf, zip archive, etc.";
4833            case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity.";
4834            case BODYSTRUCTURE: return "Record details about an anatomical structure.  This resource may be used when a coded concept does not provide the necessary detail needed for the use case.";
4835            case BUNDLE: return "A container for a collection of resources.";
4836            case CAPABILITYSTATEMENT: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation.";
4837            case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions.";
4838            case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care for a patient.";
4839            case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog.";
4840            case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation.";
4841            case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system.";
4842            case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement.";
4843            case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource.";
4844            case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter,  but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score.";
4845            case CODESYSTEM: return "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.";
4846            case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition.";
4847            case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition.";
4848            case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server.";
4849            case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.).";
4850            case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models.";
4851            case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.";
4852            case CONSENT: return "A record of a healthcare consumer?s  choices, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time.";
4853            case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.";
4854            case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.";
4855            case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy.";
4856            case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.";
4857            case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc.";
4858            case DEVICE: return "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.";
4859            case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device.";
4860            case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device.";
4861            case DEVICEREQUEST: return "Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker.";
4862            case DEVICEUSESTATEMENT: return "A record of a device being used by a patient where the record is the result of a report from the patient or another clinician.";
4863            case DIAGNOSTICREPORT: return "The findings and interpretation of diagnostic  tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports.";
4864            case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection.";
4865            case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. Provides metadata about the document so that the document can be discovered and managed. The scope of a document is any seralized object with a mime-type, so includes formal patient centric documents (CDA), cliical notes, scanned paper, and non-patient specific documents like policy text.";
4866            case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources.";
4867            case EFFECTEVIDENCESYNTHESIS: return "The EffectEvidenceSynthesis resource describes the difference in an outcome between exposures states in a population where the effect estimate is derived from a combination of research studies.";
4868            case ENCOUNTER: return "An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient.";
4869            case ENDPOINT: return "The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information.";
4870            case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage.";
4871            case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.";
4872            case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time.";
4873            case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur.";
4874            case EVIDENCE: return "The Evidence resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.";
4875            case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about.";
4876            case EXAMPLESCENARIO: return "Example of workflow instance.";
4877            case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided.";
4878            case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient.";
4879            case FLAG: return "Prospective warnings of potential issues when providing care to the patient.";
4880            case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.";
4881            case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set.";
4882            case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization.";
4883            case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken.";
4884            case HEALTHCARESERVICE: return "The details of a healthcare service available at a location.";
4885            case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context.  A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities.";
4886            case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party.";
4887            case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those  recommendations.";
4888            case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.";
4889            case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts.";
4890            case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization.";
4891            case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.";
4892            case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets.";
4893            case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\".";
4894            case LIST: return "A list is a curated collection of resources.";
4895            case LOCATION: return "Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.";
4896            case MEASURE: return "The Measure resource provides the definition of a quality measure.";
4897            case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.";
4898            case MEDIA: return "A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.";
4899            case MEDICATION: return "This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use.";
4900            case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication.  This may be as simple as swallowing a tablet or it may be a long running infusion.  Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner.";
4901            case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient.  This includes a description of the medication product (supply) provided and the instructions for administering the medication.  The medication dispense is the result of a pharmacy system responding to a medication order.";
4902            case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge.";
4903            case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns.";
4904            case MEDICATIONSTATEMENT: return "A record of a medication that is being consumed by a patient.   A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future.  The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician.  A common scenario where this information is captured is during the history taking process during a patient visit or stay.   The medication information may come from sources such as the patient's memory, from a prescription bottle,  or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medication statement is often, if not always, less specific.  There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise.  As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains.  Medication administration is more formal and is not missing detailed information.";
4905            case MEDICINALPRODUCT: return "Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).";
4906            case MEDICINALPRODUCTAUTHORIZATION: return "The regulatory authorization of a medicinal product.";
4907            case MEDICINALPRODUCTCONTRAINDICATION: return "The clinical particulars - indications, contraindications etc. of a medicinal product, including for regulatory purposes.";
4908            case MEDICINALPRODUCTINDICATION: return "Indication for the Medicinal Product.";
4909            case MEDICINALPRODUCTINGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product.";
4910            case MEDICINALPRODUCTINTERACTION: return "The interactions of the medicinal product with other medicinal products, or other forms of interactions.";
4911            case MEDICINALPRODUCTMANUFACTURED: return "The manufactured item as contained in the packaged medicinal product.";
4912            case MEDICINALPRODUCTPACKAGED: return "A medicinal product in a container or package.";
4913            case MEDICINALPRODUCTPHARMACEUTICAL: return "A pharmaceutical product described in terms of its composition and dose form.";
4914            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "Describe the undesirable effects of the medicinal product.";
4915            case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted.";
4916            case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action.  The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle.";
4917            case MOLECULARSEQUENCE: return "Raw data describing a biological sequence.";
4918            case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc.  Represents a \"System\" used within the Identifier and Coding data types.";
4919            case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.";
4920            case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject.";
4921            case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.";
4922            case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).";
4923            case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action.";
4924            case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action.  Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc.";
4925            case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.";
4926            case PARAMETERS: return "This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it.";
4927            case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services.";
4928            case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references.";
4929            case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid.";
4930            case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context.";
4931            case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.";
4932            case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare.";
4933            case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.";
4934            case PROCEDURE: return "An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy.";
4935            case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies.";
4936            case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.";
4937            case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to.";
4938            case RELATEDPERSON: return "Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.";
4939            case REQUESTGROUP: return "A group of related requests that can be used to capture intended activities that have inter-dependencies such as \"give this medication after that one\".";
4940            case RESEARCHDEFINITION: return "The ResearchDefinition resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.";
4941            case RESEARCHELEMENTDEFINITION: return "The ResearchElementDefinition resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about.";
4942            case RESEARCHSTUDY: return "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge.  This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques.  A ResearchStudy involves the gathering of information about human or animal subjects.";
4943            case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study.";
4944            case RESOURCE: return "This is the base resource type for everything.";
4945            case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.";
4946            case RISKEVIDENCESYNTHESIS: return "The RiskEvidenceSynthesis resource describes the likelihood of an outcome in a population plus exposure state where the risk estimate is derived from a combination of research studies.";
4947            case SCHEDULE: return "A container for slots of time that may be available for booking appointments.";
4948            case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource.";
4949            case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.";
4950            case SLOT: return "A slot of time on a schedule that may be available for booking appointments.";
4951            case SPECIMEN: return "A sample to be used for analysis.";
4952            case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements.";
4953            case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.";
4954            case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data.";
4955            case SUBSCRIPTION: return "The subscription resource is used to define a push-based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined \"channel\" so that another system can take an appropriate action.";
4956            case SUBSTANCE: return "A homogeneous material with a definite composition.";
4957            case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction.";
4958            case SUBSTANCEPOLYMER: return "Todo.";
4959            case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators.";
4960            case SUBSTANCEREFERENCEINFORMATION: return "Todo.";
4961            case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex.";
4962            case SUBSTANCESPECIFICATION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing.";
4963            case SUPPLYDELIVERY: return "Record of delivery of what is supplied.";
4964            case SUPPLYREQUEST: return "A record of a request for a medication, substance or device used in the healthcare setting.";
4965            case TASK: return "A task to be performed.";
4966            case TERMINOLOGYCAPABILITIES: return "A Terminology Capabilities documents a set of capabilities (behaviors) of a FHIR Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.";
4967            case TESTREPORT: return "A summary of information based on the results of executing a TestScript.";
4968            case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.";
4969            case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).";
4970            case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements.";
4971            case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient.";
4972            case TYPE: return "A place holder that means any kind of data type";
4973            case ANY: return "A place holder that means any kind of resource";
4974            case NULL: return null;
4975            default: return "?";
4976          }
4977        }
4978        public String getDisplay() {
4979          switch (this) {
4980            case ADDRESS: return "Address";
4981            case AGE: return "Age";
4982            case ANNOTATION: return "Annotation";
4983            case ATTACHMENT: return "Attachment";
4984            case BACKBONEELEMENT: return "BackboneElement";
4985            case CODEABLECONCEPT: return "CodeableConcept";
4986            case CODING: return "Coding";
4987            case CONTACTDETAIL: return "ContactDetail";
4988            case CONTACTPOINT: return "ContactPoint";
4989            case CONTRIBUTOR: return "Contributor";
4990            case COUNT: return "Count";
4991            case DATAREQUIREMENT: return "DataRequirement";
4992            case DISTANCE: return "Distance";
4993            case DOSAGE: return "Dosage";
4994            case DURATION: return "Duration";
4995            case ELEMENT: return "Element";
4996            case ELEMENTDEFINITION: return "ElementDefinition";
4997            case EXPRESSION: return "Expression";
4998            case EXTENSION: return "Extension";
4999            case HUMANNAME: return "HumanName";
5000            case IDENTIFIER: return "Identifier";
5001            case MARKETINGSTATUS: return "MarketingStatus";
5002            case META: return "Meta";
5003            case MONEY: return "Money";
5004            case MONEYQUANTITY: return "MoneyQuantity";
5005            case NARRATIVE: return "Narrative";
5006            case PARAMETERDEFINITION: return "ParameterDefinition";
5007            case PERIOD: return "Period";
5008            case POPULATION: return "Population";
5009            case PRODCHARACTERISTIC: return "ProdCharacteristic";
5010            case PRODUCTSHELFLIFE: return "ProductShelfLife";
5011            case QUANTITY: return "Quantity";
5012            case RANGE: return "Range";
5013            case RATIO: return "Ratio";
5014            case REFERENCE: return "Reference";
5015            case RELATEDARTIFACT: return "RelatedArtifact";
5016            case SAMPLEDDATA: return "SampledData";
5017            case SIGNATURE: return "Signature";
5018            case SIMPLEQUANTITY: return "SimpleQuantity";
5019            case SUBSTANCEAMOUNT: return "SubstanceAmount";
5020            case TIMING: return "Timing";
5021            case TRIGGERDEFINITION: return "TriggerDefinition";
5022            case USAGECONTEXT: return "UsageContext";
5023            case BASE64BINARY: return "base64Binary";
5024            case BOOLEAN: return "boolean";
5025            case CANONICAL: return "canonical";
5026            case CODE: return "code";
5027            case DATE: return "date";
5028            case DATETIME: return "dateTime";
5029            case DECIMAL: return "decimal";
5030            case ID: return "id";
5031            case INSTANT: return "instant";
5032            case INTEGER: return "integer";
5033            case MARKDOWN: return "markdown";
5034            case OID: return "oid";
5035            case POSITIVEINT: return "positiveInt";
5036            case STRING: return "string";
5037            case TIME: return "time";
5038            case UNSIGNEDINT: return "unsignedInt";
5039            case URI: return "uri";
5040            case URL: return "url";
5041            case UUID: return "uuid";
5042            case XHTML: return "XHTML";
5043            case ACCOUNT: return "Account";
5044            case ACTIVITYDEFINITION: return "ActivityDefinition";
5045            case ADVERSEEVENT: return "AdverseEvent";
5046            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
5047            case APPOINTMENT: return "Appointment";
5048            case APPOINTMENTRESPONSE: return "AppointmentResponse";
5049            case AUDITEVENT: return "AuditEvent";
5050            case BASIC: return "Basic";
5051            case BINARY: return "Binary";
5052            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
5053            case BODYSTRUCTURE: return "BodyStructure";
5054            case BUNDLE: return "Bundle";
5055            case CAPABILITYSTATEMENT: return "CapabilityStatement";
5056            case CAREPLAN: return "CarePlan";
5057            case CARETEAM: return "CareTeam";
5058            case CATALOGENTRY: return "CatalogEntry";
5059            case CHARGEITEM: return "ChargeItem";
5060            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
5061            case CLAIM: return "Claim";
5062            case CLAIMRESPONSE: return "ClaimResponse";
5063            case CLINICALIMPRESSION: return "ClinicalImpression";
5064            case CODESYSTEM: return "CodeSystem";
5065            case COMMUNICATION: return "Communication";
5066            case COMMUNICATIONREQUEST: return "CommunicationRequest";
5067            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
5068            case COMPOSITION: return "Composition";
5069            case CONCEPTMAP: return "ConceptMap";
5070            case CONDITION: return "Condition";
5071            case CONSENT: return "Consent";
5072            case CONTRACT: return "Contract";
5073            case COVERAGE: return "Coverage";
5074            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
5075            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
5076            case DETECTEDISSUE: return "DetectedIssue";
5077            case DEVICE: return "Device";
5078            case DEVICEDEFINITION: return "DeviceDefinition";
5079            case DEVICEMETRIC: return "DeviceMetric";
5080            case DEVICEREQUEST: return "DeviceRequest";
5081            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
5082            case DIAGNOSTICREPORT: return "DiagnosticReport";
5083            case DOCUMENTMANIFEST: return "DocumentManifest";
5084            case DOCUMENTREFERENCE: return "DocumentReference";
5085            case DOMAINRESOURCE: return "DomainResource";
5086            case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis";
5087            case ENCOUNTER: return "Encounter";
5088            case ENDPOINT: return "Endpoint";
5089            case ENROLLMENTREQUEST: return "EnrollmentRequest";
5090            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
5091            case EPISODEOFCARE: return "EpisodeOfCare";
5092            case EVENTDEFINITION: return "EventDefinition";
5093            case EVIDENCE: return "Evidence";
5094            case EVIDENCEVARIABLE: return "EvidenceVariable";
5095            case EXAMPLESCENARIO: return "ExampleScenario";
5096            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
5097            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
5098            case FLAG: return "Flag";
5099            case GOAL: return "Goal";
5100            case GRAPHDEFINITION: return "GraphDefinition";
5101            case GROUP: return "Group";
5102            case GUIDANCERESPONSE: return "GuidanceResponse";
5103            case HEALTHCARESERVICE: return "HealthcareService";
5104            case IMAGINGSTUDY: return "ImagingStudy";
5105            case IMMUNIZATION: return "Immunization";
5106            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
5107            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
5108            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
5109            case INSURANCEPLAN: return "InsurancePlan";
5110            case INVOICE: return "Invoice";
5111            case LIBRARY: return "Library";
5112            case LINKAGE: return "Linkage";
5113            case LIST: return "List";
5114            case LOCATION: return "Location";
5115            case MEASURE: return "Measure";
5116            case MEASUREREPORT: return "MeasureReport";
5117            case MEDIA: return "Media";
5118            case MEDICATION: return "Medication";
5119            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
5120            case MEDICATIONDISPENSE: return "MedicationDispense";
5121            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
5122            case MEDICATIONREQUEST: return "MedicationRequest";
5123            case MEDICATIONSTATEMENT: return "MedicationStatement";
5124            case MEDICINALPRODUCT: return "MedicinalProduct";
5125            case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization";
5126            case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication";
5127            case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication";
5128            case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient";
5129            case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction";
5130            case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured";
5131            case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged";
5132            case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical";
5133            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect";
5134            case MESSAGEDEFINITION: return "MessageDefinition";
5135            case MESSAGEHEADER: return "MessageHeader";
5136            case MOLECULARSEQUENCE: return "MolecularSequence";
5137            case NAMINGSYSTEM: return "NamingSystem";
5138            case NUTRITIONORDER: return "NutritionOrder";
5139            case OBSERVATION: return "Observation";
5140            case OBSERVATIONDEFINITION: return "ObservationDefinition";
5141            case OPERATIONDEFINITION: return "OperationDefinition";
5142            case OPERATIONOUTCOME: return "OperationOutcome";
5143            case ORGANIZATION: return "Organization";
5144            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
5145            case PARAMETERS: return "Parameters";
5146            case PATIENT: return "Patient";
5147            case PAYMENTNOTICE: return "PaymentNotice";
5148            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
5149            case PERSON: return "Person";
5150            case PLANDEFINITION: return "PlanDefinition";
5151            case PRACTITIONER: return "Practitioner";
5152            case PRACTITIONERROLE: return "PractitionerRole";
5153            case PROCEDURE: return "Procedure";
5154            case PROVENANCE: return "Provenance";
5155            case QUESTIONNAIRE: return "Questionnaire";
5156            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
5157            case RELATEDPERSON: return "RelatedPerson";
5158            case REQUESTGROUP: return "RequestGroup";
5159            case RESEARCHDEFINITION: return "ResearchDefinition";
5160            case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition";
5161            case RESEARCHSTUDY: return "ResearchStudy";
5162            case RESEARCHSUBJECT: return "ResearchSubject";
5163            case RESOURCE: return "Resource";
5164            case RISKASSESSMENT: return "RiskAssessment";
5165            case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis";
5166            case SCHEDULE: return "Schedule";
5167            case SEARCHPARAMETER: return "SearchParameter";
5168            case SERVICEREQUEST: return "ServiceRequest";
5169            case SLOT: return "Slot";
5170            case SPECIMEN: return "Specimen";
5171            case SPECIMENDEFINITION: return "SpecimenDefinition";
5172            case STRUCTUREDEFINITION: return "StructureDefinition";
5173            case STRUCTUREMAP: return "StructureMap";
5174            case SUBSCRIPTION: return "Subscription";
5175            case SUBSTANCE: return "Substance";
5176            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
5177            case SUBSTANCEPOLYMER: return "SubstancePolymer";
5178            case SUBSTANCEPROTEIN: return "SubstanceProtein";
5179            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
5180            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
5181            case SUBSTANCESPECIFICATION: return "SubstanceSpecification";
5182            case SUPPLYDELIVERY: return "SupplyDelivery";
5183            case SUPPLYREQUEST: return "SupplyRequest";
5184            case TASK: return "Task";
5185            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
5186            case TESTREPORT: return "TestReport";
5187            case TESTSCRIPT: return "TestScript";
5188            case VALUESET: return "ValueSet";
5189            case VERIFICATIONRESULT: return "VerificationResult";
5190            case VISIONPRESCRIPTION: return "VisionPrescription";
5191            case TYPE: return "Type";
5192            case ANY: return "Any";
5193            case NULL: return null;
5194            default: return "?";
5195          }
5196        }
5197    }
5198
5199  public static class FHIRAllTypesEnumFactory implements EnumFactory<FHIRAllTypes> {
5200    public FHIRAllTypes fromCode(String codeString) throws IllegalArgumentException {
5201      if (codeString == null || "".equals(codeString))
5202            if (codeString == null || "".equals(codeString))
5203                return null;
5204        if ("Address".equals(codeString))
5205          return FHIRAllTypes.ADDRESS;
5206        if ("Age".equals(codeString))
5207          return FHIRAllTypes.AGE;
5208        if ("Annotation".equals(codeString))
5209          return FHIRAllTypes.ANNOTATION;
5210        if ("Attachment".equals(codeString))
5211          return FHIRAllTypes.ATTACHMENT;
5212        if ("BackboneElement".equals(codeString))
5213          return FHIRAllTypes.BACKBONEELEMENT;
5214        if ("CodeableConcept".equals(codeString))
5215          return FHIRAllTypes.CODEABLECONCEPT;
5216        if ("Coding".equals(codeString))
5217          return FHIRAllTypes.CODING;
5218        if ("ContactDetail".equals(codeString))
5219          return FHIRAllTypes.CONTACTDETAIL;
5220        if ("ContactPoint".equals(codeString))
5221          return FHIRAllTypes.CONTACTPOINT;
5222        if ("Contributor".equals(codeString))
5223          return FHIRAllTypes.CONTRIBUTOR;
5224        if ("Count".equals(codeString))
5225          return FHIRAllTypes.COUNT;
5226        if ("DataRequirement".equals(codeString))
5227          return FHIRAllTypes.DATAREQUIREMENT;
5228        if ("Distance".equals(codeString))
5229          return FHIRAllTypes.DISTANCE;
5230        if ("Dosage".equals(codeString))
5231          return FHIRAllTypes.DOSAGE;
5232        if ("Duration".equals(codeString))
5233          return FHIRAllTypes.DURATION;
5234        if ("Element".equals(codeString))
5235          return FHIRAllTypes.ELEMENT;
5236        if ("ElementDefinition".equals(codeString))
5237          return FHIRAllTypes.ELEMENTDEFINITION;
5238        if ("Expression".equals(codeString))
5239          return FHIRAllTypes.EXPRESSION;
5240        if ("Extension".equals(codeString))
5241          return FHIRAllTypes.EXTENSION;
5242        if ("HumanName".equals(codeString))
5243          return FHIRAllTypes.HUMANNAME;
5244        if ("Identifier".equals(codeString))
5245          return FHIRAllTypes.IDENTIFIER;
5246        if ("MarketingStatus".equals(codeString))
5247          return FHIRAllTypes.MARKETINGSTATUS;
5248        if ("Meta".equals(codeString))
5249          return FHIRAllTypes.META;
5250        if ("Money".equals(codeString))
5251          return FHIRAllTypes.MONEY;
5252        if ("MoneyQuantity".equals(codeString))
5253          return FHIRAllTypes.MONEYQUANTITY;
5254        if ("Narrative".equals(codeString))
5255          return FHIRAllTypes.NARRATIVE;
5256        if ("ParameterDefinition".equals(codeString))
5257          return FHIRAllTypes.PARAMETERDEFINITION;
5258        if ("Period".equals(codeString))
5259          return FHIRAllTypes.PERIOD;
5260        if ("Population".equals(codeString))
5261          return FHIRAllTypes.POPULATION;
5262        if ("ProdCharacteristic".equals(codeString))
5263          return FHIRAllTypes.PRODCHARACTERISTIC;
5264        if ("ProductShelfLife".equals(codeString))
5265          return FHIRAllTypes.PRODUCTSHELFLIFE;
5266        if ("Quantity".equals(codeString))
5267          return FHIRAllTypes.QUANTITY;
5268        if ("Range".equals(codeString))
5269          return FHIRAllTypes.RANGE;
5270        if ("Ratio".equals(codeString))
5271          return FHIRAllTypes.RATIO;
5272        if ("Reference".equals(codeString))
5273          return FHIRAllTypes.REFERENCE;
5274        if ("RelatedArtifact".equals(codeString))
5275          return FHIRAllTypes.RELATEDARTIFACT;
5276        if ("SampledData".equals(codeString))
5277          return FHIRAllTypes.SAMPLEDDATA;
5278        if ("Signature".equals(codeString))
5279          return FHIRAllTypes.SIGNATURE;
5280        if ("SimpleQuantity".equals(codeString))
5281          return FHIRAllTypes.SIMPLEQUANTITY;
5282        if ("SubstanceAmount".equals(codeString))
5283          return FHIRAllTypes.SUBSTANCEAMOUNT;
5284        if ("Timing".equals(codeString))
5285          return FHIRAllTypes.TIMING;
5286        if ("TriggerDefinition".equals(codeString))
5287          return FHIRAllTypes.TRIGGERDEFINITION;
5288        if ("UsageContext".equals(codeString))
5289          return FHIRAllTypes.USAGECONTEXT;
5290        if ("base64Binary".equals(codeString))
5291          return FHIRAllTypes.BASE64BINARY;
5292        if ("boolean".equals(codeString))
5293          return FHIRAllTypes.BOOLEAN;
5294        if ("canonical".equals(codeString))
5295          return FHIRAllTypes.CANONICAL;
5296        if ("code".equals(codeString))
5297          return FHIRAllTypes.CODE;
5298        if ("date".equals(codeString))
5299          return FHIRAllTypes.DATE;
5300        if ("dateTime".equals(codeString))
5301          return FHIRAllTypes.DATETIME;
5302        if ("decimal".equals(codeString))
5303          return FHIRAllTypes.DECIMAL;
5304        if ("id".equals(codeString))
5305          return FHIRAllTypes.ID;
5306        if ("instant".equals(codeString))
5307          return FHIRAllTypes.INSTANT;
5308        if ("integer".equals(codeString))
5309          return FHIRAllTypes.INTEGER;
5310        if ("markdown".equals(codeString))
5311          return FHIRAllTypes.MARKDOWN;
5312        if ("oid".equals(codeString))
5313          return FHIRAllTypes.OID;
5314        if ("positiveInt".equals(codeString))
5315          return FHIRAllTypes.POSITIVEINT;
5316        if ("string".equals(codeString))
5317          return FHIRAllTypes.STRING;
5318        if ("time".equals(codeString))
5319          return FHIRAllTypes.TIME;
5320        if ("unsignedInt".equals(codeString))
5321          return FHIRAllTypes.UNSIGNEDINT;
5322        if ("uri".equals(codeString))
5323          return FHIRAllTypes.URI;
5324        if ("url".equals(codeString))
5325          return FHIRAllTypes.URL;
5326        if ("uuid".equals(codeString))
5327          return FHIRAllTypes.UUID;
5328        if ("xhtml".equals(codeString))
5329          return FHIRAllTypes.XHTML;
5330        if ("Account".equals(codeString))
5331          return FHIRAllTypes.ACCOUNT;
5332        if ("ActivityDefinition".equals(codeString))
5333          return FHIRAllTypes.ACTIVITYDEFINITION;
5334        if ("AdverseEvent".equals(codeString))
5335          return FHIRAllTypes.ADVERSEEVENT;
5336        if ("AllergyIntolerance".equals(codeString))
5337          return FHIRAllTypes.ALLERGYINTOLERANCE;
5338        if ("Appointment".equals(codeString))
5339          return FHIRAllTypes.APPOINTMENT;
5340        if ("AppointmentResponse".equals(codeString))
5341          return FHIRAllTypes.APPOINTMENTRESPONSE;
5342        if ("AuditEvent".equals(codeString))
5343          return FHIRAllTypes.AUDITEVENT;
5344        if ("Basic".equals(codeString))
5345          return FHIRAllTypes.BASIC;
5346        if ("Binary".equals(codeString))
5347          return FHIRAllTypes.BINARY;
5348        if ("BiologicallyDerivedProduct".equals(codeString))
5349          return FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT;
5350        if ("BodyStructure".equals(codeString))
5351          return FHIRAllTypes.BODYSTRUCTURE;
5352        if ("Bundle".equals(codeString))
5353          return FHIRAllTypes.BUNDLE;
5354        if ("CapabilityStatement".equals(codeString))
5355          return FHIRAllTypes.CAPABILITYSTATEMENT;
5356        if ("CarePlan".equals(codeString))
5357          return FHIRAllTypes.CAREPLAN;
5358        if ("CareTeam".equals(codeString))
5359          return FHIRAllTypes.CARETEAM;
5360        if ("CatalogEntry".equals(codeString))
5361          return FHIRAllTypes.CATALOGENTRY;
5362        if ("ChargeItem".equals(codeString))
5363          return FHIRAllTypes.CHARGEITEM;
5364        if ("ChargeItemDefinition".equals(codeString))
5365          return FHIRAllTypes.CHARGEITEMDEFINITION;
5366        if ("Claim".equals(codeString))
5367          return FHIRAllTypes.CLAIM;
5368        if ("ClaimResponse".equals(codeString))
5369          return FHIRAllTypes.CLAIMRESPONSE;
5370        if ("ClinicalImpression".equals(codeString))
5371          return FHIRAllTypes.CLINICALIMPRESSION;
5372        if ("CodeSystem".equals(codeString))
5373          return FHIRAllTypes.CODESYSTEM;
5374        if ("Communication".equals(codeString))
5375          return FHIRAllTypes.COMMUNICATION;
5376        if ("CommunicationRequest".equals(codeString))
5377          return FHIRAllTypes.COMMUNICATIONREQUEST;
5378        if ("CompartmentDefinition".equals(codeString))
5379          return FHIRAllTypes.COMPARTMENTDEFINITION;
5380        if ("Composition".equals(codeString))
5381          return FHIRAllTypes.COMPOSITION;
5382        if ("ConceptMap".equals(codeString))
5383          return FHIRAllTypes.CONCEPTMAP;
5384        if ("Condition".equals(codeString))
5385          return FHIRAllTypes.CONDITION;
5386        if ("Consent".equals(codeString))
5387          return FHIRAllTypes.CONSENT;
5388        if ("Contract".equals(codeString))
5389          return FHIRAllTypes.CONTRACT;
5390        if ("Coverage".equals(codeString))
5391          return FHIRAllTypes.COVERAGE;
5392        if ("CoverageEligibilityRequest".equals(codeString))
5393          return FHIRAllTypes.COVERAGEELIGIBILITYREQUEST;
5394        if ("CoverageEligibilityResponse".equals(codeString))
5395          return FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE;
5396        if ("DetectedIssue".equals(codeString))
5397          return FHIRAllTypes.DETECTEDISSUE;
5398        if ("Device".equals(codeString))
5399          return FHIRAllTypes.DEVICE;
5400        if ("DeviceDefinition".equals(codeString))
5401          return FHIRAllTypes.DEVICEDEFINITION;
5402        if ("DeviceMetric".equals(codeString))
5403          return FHIRAllTypes.DEVICEMETRIC;
5404        if ("DeviceRequest".equals(codeString))
5405          return FHIRAllTypes.DEVICEREQUEST;
5406        if ("DeviceUseStatement".equals(codeString))
5407          return FHIRAllTypes.DEVICEUSESTATEMENT;
5408        if ("DiagnosticReport".equals(codeString))
5409          return FHIRAllTypes.DIAGNOSTICREPORT;
5410        if ("DocumentManifest".equals(codeString))
5411          return FHIRAllTypes.DOCUMENTMANIFEST;
5412        if ("DocumentReference".equals(codeString))
5413          return FHIRAllTypes.DOCUMENTREFERENCE;
5414        if ("DomainResource".equals(codeString))
5415          return FHIRAllTypes.DOMAINRESOURCE;
5416        if ("EffectEvidenceSynthesis".equals(codeString))
5417          return FHIRAllTypes.EFFECTEVIDENCESYNTHESIS;
5418        if ("Encounter".equals(codeString))
5419          return FHIRAllTypes.ENCOUNTER;
5420        if ("Endpoint".equals(codeString))
5421          return FHIRAllTypes.ENDPOINT;
5422        if ("EnrollmentRequest".equals(codeString))
5423          return FHIRAllTypes.ENROLLMENTREQUEST;
5424        if ("EnrollmentResponse".equals(codeString))
5425          return FHIRAllTypes.ENROLLMENTRESPONSE;
5426        if ("EpisodeOfCare".equals(codeString))
5427          return FHIRAllTypes.EPISODEOFCARE;
5428        if ("EventDefinition".equals(codeString))
5429          return FHIRAllTypes.EVENTDEFINITION;
5430        if ("Evidence".equals(codeString))
5431          return FHIRAllTypes.EVIDENCE;
5432        if ("EvidenceVariable".equals(codeString))
5433          return FHIRAllTypes.EVIDENCEVARIABLE;
5434        if ("ExampleScenario".equals(codeString))
5435          return FHIRAllTypes.EXAMPLESCENARIO;
5436        if ("ExplanationOfBenefit".equals(codeString))
5437          return FHIRAllTypes.EXPLANATIONOFBENEFIT;
5438        if ("FamilyMemberHistory".equals(codeString))
5439          return FHIRAllTypes.FAMILYMEMBERHISTORY;
5440        if ("Flag".equals(codeString))
5441          return FHIRAllTypes.FLAG;
5442        if ("Goal".equals(codeString))
5443          return FHIRAllTypes.GOAL;
5444        if ("GraphDefinition".equals(codeString))
5445          return FHIRAllTypes.GRAPHDEFINITION;
5446        if ("Group".equals(codeString))
5447          return FHIRAllTypes.GROUP;
5448        if ("GuidanceResponse".equals(codeString))
5449          return FHIRAllTypes.GUIDANCERESPONSE;
5450        if ("HealthcareService".equals(codeString))
5451          return FHIRAllTypes.HEALTHCARESERVICE;
5452        if ("ImagingStudy".equals(codeString))
5453          return FHIRAllTypes.IMAGINGSTUDY;
5454        if ("Immunization".equals(codeString))
5455          return FHIRAllTypes.IMMUNIZATION;
5456        if ("ImmunizationEvaluation".equals(codeString))
5457          return FHIRAllTypes.IMMUNIZATIONEVALUATION;
5458        if ("ImmunizationRecommendation".equals(codeString))
5459          return FHIRAllTypes.IMMUNIZATIONRECOMMENDATION;
5460        if ("ImplementationGuide".equals(codeString))
5461          return FHIRAllTypes.IMPLEMENTATIONGUIDE;
5462        if ("InsurancePlan".equals(codeString))
5463          return FHIRAllTypes.INSURANCEPLAN;
5464        if ("Invoice".equals(codeString))
5465          return FHIRAllTypes.INVOICE;
5466        if ("Library".equals(codeString))
5467          return FHIRAllTypes.LIBRARY;
5468        if ("Linkage".equals(codeString))
5469          return FHIRAllTypes.LINKAGE;
5470        if ("List".equals(codeString))
5471          return FHIRAllTypes.LIST;
5472        if ("Location".equals(codeString))
5473          return FHIRAllTypes.LOCATION;
5474        if ("Measure".equals(codeString))
5475          return FHIRAllTypes.MEASURE;
5476        if ("MeasureReport".equals(codeString))
5477          return FHIRAllTypes.MEASUREREPORT;
5478        if ("Media".equals(codeString))
5479          return FHIRAllTypes.MEDIA;
5480        if ("Medication".equals(codeString))
5481          return FHIRAllTypes.MEDICATION;
5482        if ("MedicationAdministration".equals(codeString))
5483          return FHIRAllTypes.MEDICATIONADMINISTRATION;
5484        if ("MedicationDispense".equals(codeString))
5485          return FHIRAllTypes.MEDICATIONDISPENSE;
5486        if ("MedicationKnowledge".equals(codeString))
5487          return FHIRAllTypes.MEDICATIONKNOWLEDGE;
5488        if ("MedicationRequest".equals(codeString))
5489          return FHIRAllTypes.MEDICATIONREQUEST;
5490        if ("MedicationStatement".equals(codeString))
5491          return FHIRAllTypes.MEDICATIONSTATEMENT;
5492        if ("MedicinalProduct".equals(codeString))
5493          return FHIRAllTypes.MEDICINALPRODUCT;
5494        if ("MedicinalProductAuthorization".equals(codeString))
5495          return FHIRAllTypes.MEDICINALPRODUCTAUTHORIZATION;
5496        if ("MedicinalProductContraindication".equals(codeString))
5497          return FHIRAllTypes.MEDICINALPRODUCTCONTRAINDICATION;
5498        if ("MedicinalProductIndication".equals(codeString))
5499          return FHIRAllTypes.MEDICINALPRODUCTINDICATION;
5500        if ("MedicinalProductIngredient".equals(codeString))
5501          return FHIRAllTypes.MEDICINALPRODUCTINGREDIENT;
5502        if ("MedicinalProductInteraction".equals(codeString))
5503          return FHIRAllTypes.MEDICINALPRODUCTINTERACTION;
5504        if ("MedicinalProductManufactured".equals(codeString))
5505          return FHIRAllTypes.MEDICINALPRODUCTMANUFACTURED;
5506        if ("MedicinalProductPackaged".equals(codeString))
5507          return FHIRAllTypes.MEDICINALPRODUCTPACKAGED;
5508        if ("MedicinalProductPharmaceutical".equals(codeString))
5509          return FHIRAllTypes.MEDICINALPRODUCTPHARMACEUTICAL;
5510        if ("MedicinalProductUndesirableEffect".equals(codeString))
5511          return FHIRAllTypes.MEDICINALPRODUCTUNDESIRABLEEFFECT;
5512        if ("MessageDefinition".equals(codeString))
5513          return FHIRAllTypes.MESSAGEDEFINITION;
5514        if ("MessageHeader".equals(codeString))
5515          return FHIRAllTypes.MESSAGEHEADER;
5516        if ("MolecularSequence".equals(codeString))
5517          return FHIRAllTypes.MOLECULARSEQUENCE;
5518        if ("NamingSystem".equals(codeString))
5519          return FHIRAllTypes.NAMINGSYSTEM;
5520        if ("NutritionOrder".equals(codeString))
5521          return FHIRAllTypes.NUTRITIONORDER;
5522        if ("Observation".equals(codeString))
5523          return FHIRAllTypes.OBSERVATION;
5524        if ("ObservationDefinition".equals(codeString))
5525          return FHIRAllTypes.OBSERVATIONDEFINITION;
5526        if ("OperationDefinition".equals(codeString))
5527          return FHIRAllTypes.OPERATIONDEFINITION;
5528        if ("OperationOutcome".equals(codeString))
5529          return FHIRAllTypes.OPERATIONOUTCOME;
5530        if ("Organization".equals(codeString))
5531          return FHIRAllTypes.ORGANIZATION;
5532        if ("OrganizationAffiliation".equals(codeString))
5533          return FHIRAllTypes.ORGANIZATIONAFFILIATION;
5534        if ("Parameters".equals(codeString))
5535          return FHIRAllTypes.PARAMETERS;
5536        if ("Patient".equals(codeString))
5537          return FHIRAllTypes.PATIENT;
5538        if ("PaymentNotice".equals(codeString))
5539          return FHIRAllTypes.PAYMENTNOTICE;
5540        if ("PaymentReconciliation".equals(codeString))
5541          return FHIRAllTypes.PAYMENTRECONCILIATION;
5542        if ("Person".equals(codeString))
5543          return FHIRAllTypes.PERSON;
5544        if ("PlanDefinition".equals(codeString))
5545          return FHIRAllTypes.PLANDEFINITION;
5546        if ("Practitioner".equals(codeString))
5547          return FHIRAllTypes.PRACTITIONER;
5548        if ("PractitionerRole".equals(codeString))
5549          return FHIRAllTypes.PRACTITIONERROLE;
5550        if ("Procedure".equals(codeString))
5551          return FHIRAllTypes.PROCEDURE;
5552        if ("Provenance".equals(codeString))
5553          return FHIRAllTypes.PROVENANCE;
5554        if ("Questionnaire".equals(codeString))
5555          return FHIRAllTypes.QUESTIONNAIRE;
5556        if ("QuestionnaireResponse".equals(codeString))
5557          return FHIRAllTypes.QUESTIONNAIRERESPONSE;
5558        if ("RelatedPerson".equals(codeString))
5559          return FHIRAllTypes.RELATEDPERSON;
5560        if ("RequestGroup".equals(codeString))
5561          return FHIRAllTypes.REQUESTGROUP;
5562        if ("ResearchDefinition".equals(codeString))
5563          return FHIRAllTypes.RESEARCHDEFINITION;
5564        if ("ResearchElementDefinition".equals(codeString))
5565          return FHIRAllTypes.RESEARCHELEMENTDEFINITION;
5566        if ("ResearchStudy".equals(codeString))
5567          return FHIRAllTypes.RESEARCHSTUDY;
5568        if ("ResearchSubject".equals(codeString))
5569          return FHIRAllTypes.RESEARCHSUBJECT;
5570        if ("Resource".equals(codeString))
5571          return FHIRAllTypes.RESOURCE;
5572        if ("RiskAssessment".equals(codeString))
5573          return FHIRAllTypes.RISKASSESSMENT;
5574        if ("RiskEvidenceSynthesis".equals(codeString))
5575          return FHIRAllTypes.RISKEVIDENCESYNTHESIS;
5576        if ("Schedule".equals(codeString))
5577          return FHIRAllTypes.SCHEDULE;
5578        if ("SearchParameter".equals(codeString))
5579          return FHIRAllTypes.SEARCHPARAMETER;
5580        if ("ServiceRequest".equals(codeString))
5581          return FHIRAllTypes.SERVICEREQUEST;
5582        if ("Slot".equals(codeString))
5583          return FHIRAllTypes.SLOT;
5584        if ("Specimen".equals(codeString))
5585          return FHIRAllTypes.SPECIMEN;
5586        if ("SpecimenDefinition".equals(codeString))
5587          return FHIRAllTypes.SPECIMENDEFINITION;
5588        if ("StructureDefinition".equals(codeString))
5589          return FHIRAllTypes.STRUCTUREDEFINITION;
5590        if ("StructureMap".equals(codeString))
5591          return FHIRAllTypes.STRUCTUREMAP;
5592        if ("Subscription".equals(codeString))
5593          return FHIRAllTypes.SUBSCRIPTION;
5594        if ("Substance".equals(codeString))
5595          return FHIRAllTypes.SUBSTANCE;
5596        if ("SubstanceNucleicAcid".equals(codeString))
5597          return FHIRAllTypes.SUBSTANCENUCLEICACID;
5598        if ("SubstancePolymer".equals(codeString))
5599          return FHIRAllTypes.SUBSTANCEPOLYMER;
5600        if ("SubstanceProtein".equals(codeString))
5601          return FHIRAllTypes.SUBSTANCEPROTEIN;
5602        if ("SubstanceReferenceInformation".equals(codeString))
5603          return FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION;
5604        if ("SubstanceSourceMaterial".equals(codeString))
5605          return FHIRAllTypes.SUBSTANCESOURCEMATERIAL;
5606        if ("SubstanceSpecification".equals(codeString))
5607          return FHIRAllTypes.SUBSTANCESPECIFICATION;
5608        if ("SupplyDelivery".equals(codeString))
5609          return FHIRAllTypes.SUPPLYDELIVERY;
5610        if ("SupplyRequest".equals(codeString))
5611          return FHIRAllTypes.SUPPLYREQUEST;
5612        if ("Task".equals(codeString))
5613          return FHIRAllTypes.TASK;
5614        if ("TerminologyCapabilities".equals(codeString))
5615          return FHIRAllTypes.TERMINOLOGYCAPABILITIES;
5616        if ("TestReport".equals(codeString))
5617          return FHIRAllTypes.TESTREPORT;
5618        if ("TestScript".equals(codeString))
5619          return FHIRAllTypes.TESTSCRIPT;
5620        if ("ValueSet".equals(codeString))
5621          return FHIRAllTypes.VALUESET;
5622        if ("VerificationResult".equals(codeString))
5623          return FHIRAllTypes.VERIFICATIONRESULT;
5624        if ("VisionPrescription".equals(codeString))
5625          return FHIRAllTypes.VISIONPRESCRIPTION;
5626        if ("Type".equals(codeString))
5627          return FHIRAllTypes.TYPE;
5628        if ("Any".equals(codeString))
5629          return FHIRAllTypes.ANY;
5630        throw new IllegalArgumentException("Unknown FHIRAllTypes code '"+codeString+"'");
5631        }
5632        public Enumeration<FHIRAllTypes> fromType(PrimitiveType<?> code) throws FHIRException {
5633          if (code == null)
5634            return null;
5635          if (code.isEmpty())
5636            return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NULL, code);
5637          String codeString = code.asStringValue();
5638          if (codeString == null || "".equals(codeString))
5639            return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NULL, code);
5640        if ("Address".equals(codeString))
5641          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADDRESS, code);
5642        if ("Age".equals(codeString))
5643          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AGE, code);
5644        if ("Annotation".equals(codeString))
5645          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANNOTATION, code);
5646        if ("Attachment".equals(codeString))
5647          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ATTACHMENT, code);
5648        if ("BackboneElement".equals(codeString))
5649          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BACKBONEELEMENT, code);
5650        if ("CodeableConcept".equals(codeString))
5651          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODEABLECONCEPT, code);
5652        if ("Coding".equals(codeString))
5653          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODING, code);
5654        if ("ContactDetail".equals(codeString))
5655          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTDETAIL, code);
5656        if ("ContactPoint".equals(codeString))
5657          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTPOINT, code);
5658        if ("Contributor".equals(codeString))
5659          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRIBUTOR, code);
5660        if ("Count".equals(codeString))
5661          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COUNT, code);
5662        if ("DataRequirement".equals(codeString))
5663          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATAREQUIREMENT, code);
5664        if ("Distance".equals(codeString))
5665          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DISTANCE, code);
5666        if ("Dosage".equals(codeString))
5667          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOSAGE, code);
5668        if ("Duration".equals(codeString))
5669          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DURATION, code);
5670        if ("Element".equals(codeString))
5671          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENT, code);
5672        if ("ElementDefinition".equals(codeString))
5673          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENTDEFINITION, code);
5674        if ("Expression".equals(codeString))
5675          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPRESSION, code);
5676        if ("Extension".equals(codeString))
5677          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXTENSION, code);
5678        if ("HumanName".equals(codeString))
5679          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HUMANNAME, code);
5680        if ("Identifier".equals(codeString))
5681          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IDENTIFIER, code);
5682        if ("MarketingStatus".equals(codeString))
5683          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKETINGSTATUS, code);
5684        if ("Meta".equals(codeString))
5685          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.META, code);
5686        if ("Money".equals(codeString))
5687          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEY, code);
5688        if ("MoneyQuantity".equals(codeString))
5689          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEYQUANTITY, code);
5690        if ("Narrative".equals(codeString))
5691          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NARRATIVE, code);
5692        if ("ParameterDefinition".equals(codeString))
5693          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERDEFINITION, code);
5694        if ("Period".equals(codeString))
5695          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERIOD, code);
5696        if ("Population".equals(codeString))
5697          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POPULATION, code);
5698        if ("ProdCharacteristic".equals(codeString))
5699          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODCHARACTERISTIC, code);
5700        if ("ProductShelfLife".equals(codeString))
5701          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODUCTSHELFLIFE, code);
5702        if ("Quantity".equals(codeString))
5703          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUANTITY, code);
5704        if ("Range".equals(codeString))
5705          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RANGE, code);
5706        if ("Ratio".equals(codeString))
5707          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RATIO, code);
5708        if ("Reference".equals(codeString))
5709          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REFERENCE, code);
5710        if ("RelatedArtifact".equals(codeString))
5711          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDARTIFACT, code);
5712        if ("SampledData".equals(codeString))
5713          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SAMPLEDDATA, code);
5714        if ("Signature".equals(codeString))
5715          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIGNATURE, code);
5716        if ("SimpleQuantity".equals(codeString))
5717          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIMPLEQUANTITY, code);
5718        if ("SubstanceAmount".equals(codeString))
5719          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEAMOUNT, code);
5720        if ("Timing".equals(codeString))
5721          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIMING, code);
5722        if ("TriggerDefinition".equals(codeString))
5723          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TRIGGERDEFINITION, code);
5724        if ("UsageContext".equals(codeString))
5725          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.USAGECONTEXT, code);
5726        if ("base64Binary".equals(codeString))
5727          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASE64BINARY, code);
5728        if ("boolean".equals(codeString))
5729          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BOOLEAN, code);
5730        if ("canonical".equals(codeString))
5731          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CANONICAL, code);
5732        if ("code".equals(codeString))
5733          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODE, code);
5734        if ("date".equals(codeString))
5735          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATE, code);
5736        if ("dateTime".equals(codeString))
5737          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATETIME, code);
5738        if ("decimal".equals(codeString))
5739          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DECIMAL, code);
5740        if ("id".equals(codeString))
5741          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ID, code);
5742        if ("instant".equals(codeString))
5743          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSTANT, code);
5744        if ("integer".equals(codeString))
5745          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INTEGER, code);
5746        if ("markdown".equals(codeString))
5747          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKDOWN, code);
5748        if ("oid".equals(codeString))
5749          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OID, code);
5750        if ("positiveInt".equals(codeString))
5751          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POSITIVEINT, code);
5752        if ("string".equals(codeString))
5753          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRING, code);
5754        if ("time".equals(codeString))
5755          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIME, code);
5756        if ("unsignedInt".equals(codeString))
5757          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UNSIGNEDINT, code);
5758        if ("uri".equals(codeString))
5759          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URI, code);
5760        if ("url".equals(codeString))
5761          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URL, code);
5762        if ("uuid".equals(codeString))
5763          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UUID, code);
5764        if ("xhtml".equals(codeString))
5765          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.XHTML, code);
5766        if ("Account".equals(codeString))
5767          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACCOUNT, code);
5768        if ("ActivityDefinition".equals(codeString))
5769          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACTIVITYDEFINITION, code);
5770        if ("AdverseEvent".equals(codeString))
5771          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADVERSEEVENT, code);
5772        if ("AllergyIntolerance".equals(codeString))
5773          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ALLERGYINTOLERANCE, code);
5774        if ("Appointment".equals(codeString))
5775          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENT, code);
5776        if ("AppointmentResponse".equals(codeString))
5777          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENTRESPONSE, code);
5778        if ("AuditEvent".equals(codeString))
5779          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AUDITEVENT, code);
5780        if ("Basic".equals(codeString))
5781          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASIC, code);
5782        if ("Binary".equals(codeString))
5783          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BINARY, code);
5784        if ("BiologicallyDerivedProduct".equals(codeString))
5785          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT, code);
5786        if ("BodyStructure".equals(codeString))
5787          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BODYSTRUCTURE, code);
5788        if ("Bundle".equals(codeString))
5789          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BUNDLE, code);
5790        if ("CapabilityStatement".equals(codeString))
5791          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAPABILITYSTATEMENT, code);
5792        if ("CarePlan".equals(codeString))
5793          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAREPLAN, code);
5794        if ("CareTeam".equals(codeString))
5795          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CARETEAM, code);
5796        if ("CatalogEntry".equals(codeString))
5797          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CATALOGENTRY, code);
5798        if ("ChargeItem".equals(codeString))
5799          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEM, code);
5800        if ("ChargeItemDefinition".equals(codeString))
5801          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEMDEFINITION, code);
5802        if ("Claim".equals(codeString))
5803          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIM, code);
5804        if ("ClaimResponse".equals(codeString))
5805          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIMRESPONSE, code);
5806        if ("ClinicalImpression".equals(codeString))
5807          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLINICALIMPRESSION, code);
5808        if ("CodeSystem".equals(codeString))
5809          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODESYSTEM, code);
5810        if ("Communication".equals(codeString))
5811          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATION, code);
5812        if ("CommunicationRequest".equals(codeString))
5813          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATIONREQUEST, code);
5814        if ("CompartmentDefinition".equals(codeString))
5815          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPARTMENTDEFINITION, code);
5816        if ("Composition".equals(codeString))
5817          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPOSITION, code);
5818        if ("ConceptMap".equals(codeString))
5819          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONCEPTMAP, code);
5820        if ("Condition".equals(codeString))
5821          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONDITION, code);
5822        if ("Consent".equals(codeString))
5823          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONSENT, code);
5824        if ("Contract".equals(codeString))
5825          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRACT, code);
5826        if ("Coverage".equals(codeString))
5827          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGE, code);
5828        if ("CoverageEligibilityRequest".equals(codeString))
5829          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYREQUEST, code);
5830        if ("CoverageEligibilityResponse".equals(codeString))
5831          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE, code);
5832        if ("DetectedIssue".equals(codeString))
5833          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DETECTEDISSUE, code);
5834        if ("Device".equals(codeString))
5835          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICE, code);
5836        if ("DeviceDefinition".equals(codeString))
5837          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEDEFINITION, code);
5838        if ("DeviceMetric".equals(codeString))
5839          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEMETRIC, code);
5840        if ("DeviceRequest".equals(codeString))
5841          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEREQUEST, code);
5842        if ("DeviceUseStatement".equals(codeString))
5843          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEUSESTATEMENT, code);
5844        if ("DiagnosticReport".equals(codeString))
5845          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DIAGNOSTICREPORT, code);
5846        if ("DocumentManifest".equals(codeString))
5847          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTMANIFEST, code);
5848        if ("DocumentReference".equals(codeString))
5849          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTREFERENCE, code);
5850        if ("DomainResource".equals(codeString))
5851          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOMAINRESOURCE, code);
5852        if ("EffectEvidenceSynthesis".equals(codeString))
5853          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EFFECTEVIDENCESYNTHESIS, code);
5854        if ("Encounter".equals(codeString))
5855          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENCOUNTER, code);
5856        if ("Endpoint".equals(codeString))
5857          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENDPOINT, code);
5858        if ("EnrollmentRequest".equals(codeString))
5859          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTREQUEST, code);
5860        if ("EnrollmentResponse".equals(codeString))
5861          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTRESPONSE, code);
5862        if ("EpisodeOfCare".equals(codeString))
5863          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EPISODEOFCARE, code);
5864        if ("EventDefinition".equals(codeString))
5865          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVENTDEFINITION, code);
5866        if ("Evidence".equals(codeString))
5867          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCE, code);
5868        if ("EvidenceVariable".equals(codeString))
5869          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCEVARIABLE, code);
5870        if ("ExampleScenario".equals(codeString))
5871          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXAMPLESCENARIO, code);
5872        if ("ExplanationOfBenefit".equals(codeString))
5873          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPLANATIONOFBENEFIT, code);
5874        if ("FamilyMemberHistory".equals(codeString))
5875          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FAMILYMEMBERHISTORY, code);
5876        if ("Flag".equals(codeString))
5877          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FLAG, code);
5878        if ("Goal".equals(codeString))
5879          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GOAL, code);
5880        if ("GraphDefinition".equals(codeString))
5881          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GRAPHDEFINITION, code);
5882        if ("Group".equals(codeString))
5883          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GROUP, code);
5884        if ("GuidanceResponse".equals(codeString))
5885          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GUIDANCERESPONSE, code);
5886        if ("HealthcareService".equals(codeString))
5887          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HEALTHCARESERVICE, code);
5888        if ("ImagingStudy".equals(codeString))
5889          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMAGINGSTUDY, code);
5890        if ("Immunization".equals(codeString))
5891          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATION, code);
5892        if ("ImmunizationEvaluation".equals(codeString))
5893          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONEVALUATION, code);
5894        if ("ImmunizationRecommendation".equals(codeString))
5895          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONRECOMMENDATION, code);
5896        if ("ImplementationGuide".equals(codeString))
5897          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMPLEMENTATIONGUIDE, code);
5898        if ("InsurancePlan".equals(codeString))
5899          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSURANCEPLAN, code);
5900        if ("Invoice".equals(codeString))
5901          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INVOICE, code);
5902        if ("Library".equals(codeString))
5903          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIBRARY, code);
5904        if ("Linkage".equals(codeString))
5905          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LINKAGE, code);
5906        if ("List".equals(codeString))
5907          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIST, code);
5908        if ("Location".equals(codeString))
5909          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LOCATION, code);
5910        if ("Measure".equals(codeString))
5911          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASURE, code);
5912        if ("MeasureReport".equals(codeString))
5913          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASUREREPORT, code);
5914        if ("Media".equals(codeString))
5915          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDIA, code);
5916        if ("Medication".equals(codeString))
5917          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATION, code);
5918        if ("MedicationAdministration".equals(codeString))
5919          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONADMINISTRATION, code);
5920        if ("MedicationDispense".equals(codeString))
5921          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONDISPENSE, code);
5922        if ("MedicationKnowledge".equals(codeString))
5923          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONKNOWLEDGE, code);
5924        if ("MedicationRequest".equals(codeString))
5925          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONREQUEST, code);
5926        if ("MedicationStatement".equals(codeString))
5927          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONSTATEMENT, code);
5928        if ("MedicinalProduct".equals(codeString))
5929          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCT, code);
5930        if ("MedicinalProductAuthorization".equals(codeString))
5931          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTAUTHORIZATION, code);
5932        if ("MedicinalProductContraindication".equals(codeString))
5933          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTCONTRAINDICATION, code);
5934        if ("MedicinalProductIndication".equals(codeString))
5935          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTINDICATION, code);
5936        if ("MedicinalProductIngredient".equals(codeString))
5937          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTINGREDIENT, code);
5938        if ("MedicinalProductInteraction".equals(codeString))
5939          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTINTERACTION, code);
5940        if ("MedicinalProductManufactured".equals(codeString))
5941          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTMANUFACTURED, code);
5942        if ("MedicinalProductPackaged".equals(codeString))
5943          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTPACKAGED, code);
5944        if ("MedicinalProductPharmaceutical".equals(codeString))
5945          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTPHARMACEUTICAL, code);
5946        if ("MedicinalProductUndesirableEffect".equals(codeString))
5947          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTUNDESIRABLEEFFECT, code);
5948        if ("MessageDefinition".equals(codeString))
5949          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEDEFINITION, code);
5950        if ("MessageHeader".equals(codeString))
5951          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEHEADER, code);
5952        if ("MolecularSequence".equals(codeString))
5953          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MOLECULARSEQUENCE, code);
5954        if ("NamingSystem".equals(codeString))
5955          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NAMINGSYSTEM, code);
5956        if ("NutritionOrder".equals(codeString))
5957          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NUTRITIONORDER, code);
5958        if ("Observation".equals(codeString))
5959          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATION, code);
5960        if ("ObservationDefinition".equals(codeString))
5961          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATIONDEFINITION, code);
5962        if ("OperationDefinition".equals(codeString))
5963          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONDEFINITION, code);
5964        if ("OperationOutcome".equals(codeString))
5965          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONOUTCOME, code);
5966        if ("Organization".equals(codeString))
5967          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATION, code);
5968        if ("OrganizationAffiliation".equals(codeString))
5969          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATIONAFFILIATION, code);
5970        if ("Parameters".equals(codeString))
5971          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERS, code);
5972        if ("Patient".equals(codeString))
5973          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PATIENT, code);
5974        if ("PaymentNotice".equals(codeString))
5975          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTNOTICE, code);
5976        if ("PaymentReconciliation".equals(codeString))
5977          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTRECONCILIATION, code);
5978        if ("Person".equals(codeString))
5979          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERSON, code);
5980        if ("PlanDefinition".equals(codeString))
5981          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PLANDEFINITION, code);
5982        if ("Practitioner".equals(codeString))
5983          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONER, code);
5984        if ("PractitionerRole".equals(codeString))
5985          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONERROLE, code);
5986        if ("Procedure".equals(codeString))
5987          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROCEDURE, code);
5988        if ("Provenance".equals(codeString))
5989          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROVENANCE, code);
5990        if ("Questionnaire".equals(codeString))
5991          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRE, code);
5992        if ("QuestionnaireResponse".equals(codeString))
5993          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRERESPONSE, code);
5994        if ("RelatedPerson".equals(codeString))
5995          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDPERSON, code);
5996        if ("RequestGroup".equals(codeString))
5997          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REQUESTGROUP, code);
5998        if ("ResearchDefinition".equals(codeString))
5999          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHDEFINITION, code);
6000        if ("ResearchElementDefinition".equals(codeString))
6001          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHELEMENTDEFINITION, code);
6002        if ("ResearchStudy".equals(codeString))
6003          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSTUDY, code);
6004        if ("ResearchSubject".equals(codeString))
6005          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSUBJECT, code);
6006        if ("Resource".equals(codeString))
6007          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESOURCE, code);
6008        if ("RiskAssessment".equals(codeString))
6009          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RISKASSESSMENT, code);
6010        if ("RiskEvidenceSynthesis".equals(codeString))
6011          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RISKEVIDENCESYNTHESIS, code);
6012        if ("Schedule".equals(codeString))
6013          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SCHEDULE, code);
6014        if ("SearchParameter".equals(codeString))
6015          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SEARCHPARAMETER, code);
6016        if ("ServiceRequest".equals(codeString))
6017          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SERVICEREQUEST, code);
6018        if ("Slot".equals(codeString))
6019          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SLOT, code);
6020        if ("Specimen".equals(codeString))
6021          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMEN, code);
6022        if ("SpecimenDefinition".equals(codeString))
6023          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMENDEFINITION, code);
6024        if ("StructureDefinition".equals(codeString))
6025          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREDEFINITION, code);
6026        if ("StructureMap".equals(codeString))
6027          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREMAP, code);
6028        if ("Subscription".equals(codeString))
6029          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSCRIPTION, code);
6030        if ("Substance".equals(codeString))
6031          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCE, code);
6032        if ("SubstanceNucleicAcid".equals(codeString))
6033          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCENUCLEICACID, code);
6034        if ("SubstancePolymer".equals(codeString))
6035          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPOLYMER, code);
6036        if ("SubstanceProtein".equals(codeString))
6037          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPROTEIN, code);
6038        if ("SubstanceReferenceInformation".equals(codeString))
6039          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION, code);
6040        if ("SubstanceSourceMaterial".equals(codeString))
6041          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCESOURCEMATERIAL, code);
6042        if ("SubstanceSpecification".equals(codeString))
6043          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCESPECIFICATION, code);
6044        if ("SupplyDelivery".equals(codeString))
6045          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYDELIVERY, code);
6046        if ("SupplyRequest".equals(codeString))
6047          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYREQUEST, code);
6048        if ("Task".equals(codeString))
6049          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TASK, code);
6050        if ("TerminologyCapabilities".equals(codeString))
6051          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TERMINOLOGYCAPABILITIES, code);
6052        if ("TestReport".equals(codeString))
6053          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTREPORT, code);
6054        if ("TestScript".equals(codeString))
6055          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTSCRIPT, code);
6056        if ("ValueSet".equals(codeString))
6057          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VALUESET, code);
6058        if ("VerificationResult".equals(codeString))
6059          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VERIFICATIONRESULT, code);
6060        if ("VisionPrescription".equals(codeString))
6061          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VISIONPRESCRIPTION, code);
6062        if ("Type".equals(codeString))
6063          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TYPE, code);
6064        if ("Any".equals(codeString))
6065          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANY, code);
6066        throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'");
6067        }
6068    public String toCode(FHIRAllTypes code) {
6069      if (code == FHIRAllTypes.ADDRESS)
6070        return "Address";
6071      if (code == FHIRAllTypes.AGE)
6072        return "Age";
6073      if (code == FHIRAllTypes.ANNOTATION)
6074        return "Annotation";
6075      if (code == FHIRAllTypes.ATTACHMENT)
6076        return "Attachment";
6077      if (code == FHIRAllTypes.BACKBONEELEMENT)
6078        return "BackboneElement";
6079      if (code == FHIRAllTypes.CODEABLECONCEPT)
6080        return "CodeableConcept";
6081      if (code == FHIRAllTypes.CODING)
6082        return "Coding";
6083      if (code == FHIRAllTypes.CONTACTDETAIL)
6084        return "ContactDetail";
6085      if (code == FHIRAllTypes.CONTACTPOINT)
6086        return "ContactPoint";
6087      if (code == FHIRAllTypes.CONTRIBUTOR)
6088        return "Contributor";
6089      if (code == FHIRAllTypes.COUNT)
6090        return "Count";
6091      if (code == FHIRAllTypes.DATAREQUIREMENT)
6092        return "DataRequirement";
6093      if (code == FHIRAllTypes.DISTANCE)
6094        return "Distance";
6095      if (code == FHIRAllTypes.DOSAGE)
6096        return "Dosage";
6097      if (code == FHIRAllTypes.DURATION)
6098        return "Duration";
6099      if (code == FHIRAllTypes.ELEMENT)
6100        return "Element";
6101      if (code == FHIRAllTypes.ELEMENTDEFINITION)
6102        return "ElementDefinition";
6103      if (code == FHIRAllTypes.EXPRESSION)
6104        return "Expression";
6105      if (code == FHIRAllTypes.EXTENSION)
6106        return "Extension";
6107      if (code == FHIRAllTypes.HUMANNAME)
6108        return "HumanName";
6109      if (code == FHIRAllTypes.IDENTIFIER)
6110        return "Identifier";
6111      if (code == FHIRAllTypes.MARKETINGSTATUS)
6112        return "MarketingStatus";
6113      if (code == FHIRAllTypes.META)
6114        return "Meta";
6115      if (code == FHIRAllTypes.MONEY)
6116        return "Money";
6117      if (code == FHIRAllTypes.MONEYQUANTITY)
6118        return "MoneyQuantity";
6119      if (code == FHIRAllTypes.NARRATIVE)
6120        return "Narrative";
6121      if (code == FHIRAllTypes.PARAMETERDEFINITION)
6122        return "ParameterDefinition";
6123      if (code == FHIRAllTypes.PERIOD)
6124        return "Period";
6125      if (code == FHIRAllTypes.POPULATION)
6126        return "Population";
6127      if (code == FHIRAllTypes.PRODCHARACTERISTIC)
6128        return "ProdCharacteristic";
6129      if (code == FHIRAllTypes.PRODUCTSHELFLIFE)
6130        return "ProductShelfLife";
6131      if (code == FHIRAllTypes.QUANTITY)
6132        return "Quantity";
6133      if (code == FHIRAllTypes.RANGE)
6134        return "Range";
6135      if (code == FHIRAllTypes.RATIO)
6136        return "Ratio";
6137      if (code == FHIRAllTypes.REFERENCE)
6138        return "Reference";
6139      if (code == FHIRAllTypes.RELATEDARTIFACT)
6140        return "RelatedArtifact";
6141      if (code == FHIRAllTypes.SAMPLEDDATA)
6142        return "SampledData";
6143      if (code == FHIRAllTypes.SIGNATURE)
6144        return "Signature";
6145      if (code == FHIRAllTypes.SIMPLEQUANTITY)
6146        return "SimpleQuantity";
6147      if (code == FHIRAllTypes.SUBSTANCEAMOUNT)
6148        return "SubstanceAmount";
6149      if (code == FHIRAllTypes.TIMING)
6150        return "Timing";
6151      if (code == FHIRAllTypes.TRIGGERDEFINITION)
6152        return "TriggerDefinition";
6153      if (code == FHIRAllTypes.USAGECONTEXT)
6154        return "UsageContext";
6155      if (code == FHIRAllTypes.BASE64BINARY)
6156        return "base64Binary";
6157      if (code == FHIRAllTypes.BOOLEAN)
6158        return "boolean";
6159      if (code == FHIRAllTypes.CANONICAL)
6160        return "canonical";
6161      if (code == FHIRAllTypes.CODE)
6162        return "code";
6163      if (code == FHIRAllTypes.DATE)
6164        return "date";
6165      if (code == FHIRAllTypes.DATETIME)
6166        return "dateTime";
6167      if (code == FHIRAllTypes.DECIMAL)
6168        return "decimal";
6169      if (code == FHIRAllTypes.ID)
6170        return "id";
6171      if (code == FHIRAllTypes.INSTANT)
6172        return "instant";
6173      if (code == FHIRAllTypes.INTEGER)
6174        return "integer";
6175      if (code == FHIRAllTypes.MARKDOWN)
6176        return "markdown";
6177      if (code == FHIRAllTypes.OID)
6178        return "oid";
6179      if (code == FHIRAllTypes.POSITIVEINT)
6180        return "positiveInt";
6181      if (code == FHIRAllTypes.STRING)
6182        return "string";
6183      if (code == FHIRAllTypes.TIME)
6184        return "time";
6185      if (code == FHIRAllTypes.UNSIGNEDINT)
6186        return "unsignedInt";
6187      if (code == FHIRAllTypes.URI)
6188        return "uri";
6189      if (code == FHIRAllTypes.URL)
6190        return "url";
6191      if (code == FHIRAllTypes.UUID)
6192        return "uuid";
6193      if (code == FHIRAllTypes.XHTML)
6194        return "xhtml";
6195      if (code == FHIRAllTypes.ACCOUNT)
6196        return "Account";
6197      if (code == FHIRAllTypes.ACTIVITYDEFINITION)
6198        return "ActivityDefinition";
6199      if (code == FHIRAllTypes.ADVERSEEVENT)
6200        return "AdverseEvent";
6201      if (code == FHIRAllTypes.ALLERGYINTOLERANCE)
6202        return "AllergyIntolerance";
6203      if (code == FHIRAllTypes.APPOINTMENT)
6204        return "Appointment";
6205      if (code == FHIRAllTypes.APPOINTMENTRESPONSE)
6206        return "AppointmentResponse";
6207      if (code == FHIRAllTypes.AUDITEVENT)
6208        return "AuditEvent";
6209      if (code == FHIRAllTypes.BASIC)
6210        return "Basic";
6211      if (code == FHIRAllTypes.BINARY)
6212        return "Binary";
6213      if (code == FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT)
6214        return "BiologicallyDerivedProduct";
6215      if (code == FHIRAllTypes.BODYSTRUCTURE)
6216        return "BodyStructure";
6217      if (code == FHIRAllTypes.BUNDLE)
6218        return "Bundle";
6219      if (code == FHIRAllTypes.CAPABILITYSTATEMENT)
6220        return "CapabilityStatement";
6221      if (code == FHIRAllTypes.CAREPLAN)
6222        return "CarePlan";
6223      if (code == FHIRAllTypes.CARETEAM)
6224        return "CareTeam";
6225      if (code == FHIRAllTypes.CATALOGENTRY)
6226        return "CatalogEntry";
6227      if (code == FHIRAllTypes.CHARGEITEM)
6228        return "ChargeItem";
6229      if (code == FHIRAllTypes.CHARGEITEMDEFINITION)
6230        return "ChargeItemDefinition";
6231      if (code == FHIRAllTypes.CLAIM)
6232        return "Claim";
6233      if (code == FHIRAllTypes.CLAIMRESPONSE)
6234        return "ClaimResponse";
6235      if (code == FHIRAllTypes.CLINICALIMPRESSION)
6236        return "ClinicalImpression";
6237      if (code == FHIRAllTypes.CODESYSTEM)
6238        return "CodeSystem";
6239      if (code == FHIRAllTypes.COMMUNICATION)
6240        return "Communication";
6241      if (code == FHIRAllTypes.COMMUNICATIONREQUEST)
6242        return "CommunicationRequest";
6243      if (code == FHIRAllTypes.COMPARTMENTDEFINITION)
6244        return "CompartmentDefinition";
6245      if (code == FHIRAllTypes.COMPOSITION)
6246        return "Composition";
6247      if (code == FHIRAllTypes.CONCEPTMAP)
6248        return "ConceptMap";
6249      if (code == FHIRAllTypes.CONDITION)
6250        return "Condition";
6251      if (code == FHIRAllTypes.CONSENT)
6252        return "Consent";
6253      if (code == FHIRAllTypes.CONTRACT)
6254        return "Contract";
6255      if (code == FHIRAllTypes.COVERAGE)
6256        return "Coverage";
6257      if (code == FHIRAllTypes.COVERAGEELIGIBILITYREQUEST)
6258        return "CoverageEligibilityRequest";
6259      if (code == FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE)
6260        return "CoverageEligibilityResponse";
6261      if (code == FHIRAllTypes.DETECTEDISSUE)
6262        return "DetectedIssue";
6263      if (code == FHIRAllTypes.DEVICE)
6264        return "Device";
6265      if (code == FHIRAllTypes.DEVICEDEFINITION)
6266        return "DeviceDefinition";
6267      if (code == FHIRAllTypes.DEVICEMETRIC)
6268        return "DeviceMetric";
6269      if (code == FHIRAllTypes.DEVICEREQUEST)
6270        return "DeviceRequest";
6271      if (code == FHIRAllTypes.DEVICEUSESTATEMENT)
6272        return "DeviceUseStatement";
6273      if (code == FHIRAllTypes.DIAGNOSTICREPORT)
6274        return "DiagnosticReport";
6275      if (code == FHIRAllTypes.DOCUMENTMANIFEST)
6276        return "DocumentManifest";
6277      if (code == FHIRAllTypes.DOCUMENTREFERENCE)
6278        return "DocumentReference";
6279      if (code == FHIRAllTypes.DOMAINRESOURCE)
6280        return "DomainResource";
6281      if (code == FHIRAllTypes.EFFECTEVIDENCESYNTHESIS)
6282        return "EffectEvidenceSynthesis";
6283      if (code == FHIRAllTypes.ENCOUNTER)
6284        return "Encounter";
6285      if (code == FHIRAllTypes.ENDPOINT)
6286        return "Endpoint";
6287      if (code == FHIRAllTypes.ENROLLMENTREQUEST)
6288        return "EnrollmentRequest";
6289      if (code == FHIRAllTypes.ENROLLMENTRESPONSE)
6290        return "EnrollmentResponse";
6291      if (code == FHIRAllTypes.EPISODEOFCARE)
6292        return "EpisodeOfCare";
6293      if (code == FHIRAllTypes.EVENTDEFINITION)
6294        return "EventDefinition";
6295      if (code == FHIRAllTypes.EVIDENCE)
6296        return "Evidence";
6297      if (code == FHIRAllTypes.EVIDENCEVARIABLE)
6298        return "EvidenceVariable";
6299      if (code == FHIRAllTypes.EXAMPLESCENARIO)
6300        return "ExampleScenario";
6301      if (code == FHIRAllTypes.EXPLANATIONOFBENEFIT)
6302        return "ExplanationOfBenefit";
6303      if (code == FHIRAllTypes.FAMILYMEMBERHISTORY)
6304        return "FamilyMemberHistory";
6305      if (code == FHIRAllTypes.FLAG)
6306        return "Flag";
6307      if (code == FHIRAllTypes.GOAL)
6308        return "Goal";
6309      if (code == FHIRAllTypes.GRAPHDEFINITION)
6310        return "GraphDefinition";
6311      if (code == FHIRAllTypes.GROUP)
6312        return "Group";
6313      if (code == FHIRAllTypes.GUIDANCERESPONSE)
6314        return "GuidanceResponse";
6315      if (code == FHIRAllTypes.HEALTHCARESERVICE)
6316        return "HealthcareService";
6317      if (code == FHIRAllTypes.IMAGINGSTUDY)
6318        return "ImagingStudy";
6319      if (code == FHIRAllTypes.IMMUNIZATION)
6320        return "Immunization";
6321      if (code == FHIRAllTypes.IMMUNIZATIONEVALUATION)
6322        return "ImmunizationEvaluation";
6323      if (code == FHIRAllTypes.IMMUNIZATIONRECOMMENDATION)
6324        return "ImmunizationRecommendation";
6325      if (code == FHIRAllTypes.IMPLEMENTATIONGUIDE)
6326        return "ImplementationGuide";
6327      if (code == FHIRAllTypes.INSURANCEPLAN)
6328        return "InsurancePlan";
6329      if (code == FHIRAllTypes.INVOICE)
6330        return "Invoice";
6331      if (code == FHIRAllTypes.LIBRARY)
6332        return "Library";
6333      if (code == FHIRAllTypes.LINKAGE)
6334        return "Linkage";
6335      if (code == FHIRAllTypes.LIST)
6336        return "List";
6337      if (code == FHIRAllTypes.LOCATION)
6338        return "Location";
6339      if (code == FHIRAllTypes.MEASURE)
6340        return "Measure";
6341      if (code == FHIRAllTypes.MEASUREREPORT)
6342        return "MeasureReport";
6343      if (code == FHIRAllTypes.MEDIA)
6344        return "Media";
6345      if (code == FHIRAllTypes.MEDICATION)
6346        return "Medication";
6347      if (code == FHIRAllTypes.MEDICATIONADMINISTRATION)
6348        return "MedicationAdministration";
6349      if (code == FHIRAllTypes.MEDICATIONDISPENSE)
6350        return "MedicationDispense";
6351      if (code == FHIRAllTypes.MEDICATIONKNOWLEDGE)
6352        return "MedicationKnowledge";
6353      if (code == FHIRAllTypes.MEDICATIONREQUEST)
6354        return "MedicationRequest";
6355      if (code == FHIRAllTypes.MEDICATIONSTATEMENT)
6356        return "MedicationStatement";
6357      if (code == FHIRAllTypes.MEDICINALPRODUCT)
6358        return "MedicinalProduct";
6359      if (code == FHIRAllTypes.MEDICINALPRODUCTAUTHORIZATION)
6360        return "MedicinalProductAuthorization";
6361      if (code == FHIRAllTypes.MEDICINALPRODUCTCONTRAINDICATION)
6362        return "MedicinalProductContraindication";
6363      if (code == FHIRAllTypes.MEDICINALPRODUCTINDICATION)
6364        return "MedicinalProductIndication";
6365      if (code == FHIRAllTypes.MEDICINALPRODUCTINGREDIENT)
6366        return "MedicinalProductIngredient";
6367      if (code == FHIRAllTypes.MEDICINALPRODUCTINTERACTION)
6368        return "MedicinalProductInteraction";
6369      if (code == FHIRAllTypes.MEDICINALPRODUCTMANUFACTURED)
6370        return "MedicinalProductManufactured";
6371      if (code == FHIRAllTypes.MEDICINALPRODUCTPACKAGED)
6372        return "MedicinalProductPackaged";
6373      if (code == FHIRAllTypes.MEDICINALPRODUCTPHARMACEUTICAL)
6374        return "MedicinalProductPharmaceutical";
6375      if (code == FHIRAllTypes.MEDICINALPRODUCTUNDESIRABLEEFFECT)
6376        return "MedicinalProductUndesirableEffect";
6377      if (code == FHIRAllTypes.MESSAGEDEFINITION)
6378        return "MessageDefinition";
6379      if (code == FHIRAllTypes.MESSAGEHEADER)
6380        return "MessageHeader";
6381      if (code == FHIRAllTypes.MOLECULARSEQUENCE)
6382        return "MolecularSequence";
6383      if (code == FHIRAllTypes.NAMINGSYSTEM)
6384        return "NamingSystem";
6385      if (code == FHIRAllTypes.NUTRITIONORDER)
6386        return "NutritionOrder";
6387      if (code == FHIRAllTypes.OBSERVATION)
6388        return "Observation";
6389      if (code == FHIRAllTypes.OBSERVATIONDEFINITION)
6390        return "ObservationDefinition";
6391      if (code == FHIRAllTypes.OPERATIONDEFINITION)
6392        return "OperationDefinition";
6393      if (code == FHIRAllTypes.OPERATIONOUTCOME)
6394        return "OperationOutcome";
6395      if (code == FHIRAllTypes.ORGANIZATION)
6396        return "Organization";
6397      if (code == FHIRAllTypes.ORGANIZATIONAFFILIATION)
6398        return "OrganizationAffiliation";
6399      if (code == FHIRAllTypes.PARAMETERS)
6400        return "Parameters";
6401      if (code == FHIRAllTypes.PATIENT)
6402        return "Patient";
6403      if (code == FHIRAllTypes.PAYMENTNOTICE)
6404        return "PaymentNotice";
6405      if (code == FHIRAllTypes.PAYMENTRECONCILIATION)
6406        return "PaymentReconciliation";
6407      if (code == FHIRAllTypes.PERSON)
6408        return "Person";
6409      if (code == FHIRAllTypes.PLANDEFINITION)
6410        return "PlanDefinition";
6411      if (code == FHIRAllTypes.PRACTITIONER)
6412        return "Practitioner";
6413      if (code == FHIRAllTypes.PRACTITIONERROLE)
6414        return "PractitionerRole";
6415      if (code == FHIRAllTypes.PROCEDURE)
6416        return "Procedure";
6417      if (code == FHIRAllTypes.PROVENANCE)
6418        return "Provenance";
6419      if (code == FHIRAllTypes.QUESTIONNAIRE)
6420        return "Questionnaire";
6421      if (code == FHIRAllTypes.QUESTIONNAIRERESPONSE)
6422        return "QuestionnaireResponse";
6423      if (code == FHIRAllTypes.RELATEDPERSON)
6424        return "RelatedPerson";
6425      if (code == FHIRAllTypes.REQUESTGROUP)
6426        return "RequestGroup";
6427      if (code == FHIRAllTypes.RESEARCHDEFINITION)
6428        return "ResearchDefinition";
6429      if (code == FHIRAllTypes.RESEARCHELEMENTDEFINITION)
6430        return "ResearchElementDefinition";
6431      if (code == FHIRAllTypes.RESEARCHSTUDY)
6432        return "ResearchStudy";
6433      if (code == FHIRAllTypes.RESEARCHSUBJECT)
6434        return "ResearchSubject";
6435      if (code == FHIRAllTypes.RESOURCE)
6436        return "Resource";
6437      if (code == FHIRAllTypes.RISKASSESSMENT)
6438        return "RiskAssessment";
6439      if (code == FHIRAllTypes.RISKEVIDENCESYNTHESIS)
6440        return "RiskEvidenceSynthesis";
6441      if (code == FHIRAllTypes.SCHEDULE)
6442        return "Schedule";
6443      if (code == FHIRAllTypes.SEARCHPARAMETER)
6444        return "SearchParameter";
6445      if (code == FHIRAllTypes.SERVICEREQUEST)
6446        return "ServiceRequest";
6447      if (code == FHIRAllTypes.SLOT)
6448        return "Slot";
6449      if (code == FHIRAllTypes.SPECIMEN)
6450        return "Specimen";
6451      if (code == FHIRAllTypes.SPECIMENDEFINITION)
6452        return "SpecimenDefinition";
6453      if (code == FHIRAllTypes.STRUCTUREDEFINITION)
6454        return "StructureDefinition";
6455      if (code == FHIRAllTypes.STRUCTUREMAP)
6456        return "StructureMap";
6457      if (code == FHIRAllTypes.SUBSCRIPTION)
6458        return "Subscription";
6459      if (code == FHIRAllTypes.SUBSTANCE)
6460        return "Substance";
6461      if (code == FHIRAllTypes.SUBSTANCENUCLEICACID)
6462        return "SubstanceNucleicAcid";
6463      if (code == FHIRAllTypes.SUBSTANCEPOLYMER)
6464        return "SubstancePolymer";
6465      if (code == FHIRAllTypes.SUBSTANCEPROTEIN)
6466        return "SubstanceProtein";
6467      if (code == FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION)
6468        return "SubstanceReferenceInformation";
6469      if (code == FHIRAllTypes.SUBSTANCESOURCEMATERIAL)
6470        return "SubstanceSourceMaterial";
6471      if (code == FHIRAllTypes.SUBSTANCESPECIFICATION)
6472        return "SubstanceSpecification";
6473      if (code == FHIRAllTypes.SUPPLYDELIVERY)
6474        return "SupplyDelivery";
6475      if (code == FHIRAllTypes.SUPPLYREQUEST)
6476        return "SupplyRequest";
6477      if (code == FHIRAllTypes.TASK)
6478        return "Task";
6479      if (code == FHIRAllTypes.TERMINOLOGYCAPABILITIES)
6480        return "TerminologyCapabilities";
6481      if (code == FHIRAllTypes.TESTREPORT)
6482        return "TestReport";
6483      if (code == FHIRAllTypes.TESTSCRIPT)
6484        return "TestScript";
6485      if (code == FHIRAllTypes.VALUESET)
6486        return "ValueSet";
6487      if (code == FHIRAllTypes.VERIFICATIONRESULT)
6488        return "VerificationResult";
6489      if (code == FHIRAllTypes.VISIONPRESCRIPTION)
6490        return "VisionPrescription";
6491      if (code == FHIRAllTypes.TYPE)
6492        return "Type";
6493      if (code == FHIRAllTypes.ANY)
6494        return "Any";
6495      return "?";
6496      }
6497    public String toSystem(FHIRAllTypes code) {
6498      return code.getSystem();
6499      }
6500    }
6501
6502    public enum FHIRDefinedType {
6503        /**
6504         * An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.
6505         */
6506        ADDRESS, 
6507        /**
6508         * A duration of time during which an organism (or a process) has existed.
6509         */
6510        AGE, 
6511        /**
6512         * A  text note which also  contains information about who made the statement and when.
6513         */
6514        ANNOTATION, 
6515        /**
6516         * For referring to data content defined in other formats.
6517         */
6518        ATTACHMENT, 
6519        /**
6520         * Base definition for all elements that are defined inside a resource - but not those in a data type.
6521         */
6522        BACKBONEELEMENT, 
6523        /**
6524         * A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
6525         */
6526        CODEABLECONCEPT, 
6527        /**
6528         * A reference to a code defined by a terminology system.
6529         */
6530        CODING, 
6531        /**
6532         * Specifies contact information for a person or organization.
6533         */
6534        CONTACTDETAIL, 
6535        /**
6536         * Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
6537         */
6538        CONTACTPOINT, 
6539        /**
6540         * A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
6541         */
6542        CONTRIBUTOR, 
6543        /**
6544         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
6545         */
6546        COUNT, 
6547        /**
6548         * Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
6549         */
6550        DATAREQUIREMENT, 
6551        /**
6552         * A length - a value with a unit that is a physical distance.
6553         */
6554        DISTANCE, 
6555        /**
6556         * Indicates how the medication is/was taken or should be taken by the patient.
6557         */
6558        DOSAGE, 
6559        /**
6560         * A length of time.
6561         */
6562        DURATION, 
6563        /**
6564         * Base definition for all elements in a resource.
6565         */
6566        ELEMENT, 
6567        /**
6568         * Captures constraints on each element within the resource, profile, or extension.
6569         */
6570        ELEMENTDEFINITION, 
6571        /**
6572         * A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
6573         */
6574        EXPRESSION, 
6575        /**
6576         * Optional Extension Element - found in all resources.
6577         */
6578        EXTENSION, 
6579        /**
6580         * A human's name with the ability to identify parts and usage.
6581         */
6582        HUMANNAME, 
6583        /**
6584         * An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
6585         */
6586        IDENTIFIER, 
6587        /**
6588         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
6589         */
6590        MARKETINGSTATUS, 
6591        /**
6592         * The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
6593         */
6594        META, 
6595        /**
6596         * An amount of economic utility in some recognized currency.
6597         */
6598        MONEY, 
6599        /**
6600         * null
6601         */
6602        MONEYQUANTITY, 
6603        /**
6604         * A human-readable summary of the resource conveying the essential clinical and business information for the resource.
6605         */
6606        NARRATIVE, 
6607        /**
6608         * The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
6609         */
6610        PARAMETERDEFINITION, 
6611        /**
6612         * A time period defined by a start and end date and optionally time.
6613         */
6614        PERIOD, 
6615        /**
6616         * A populatioof people with some set of grouping criteria.
6617         */
6618        POPULATION, 
6619        /**
6620         * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
6621         */
6622        PRODCHARACTERISTIC, 
6623        /**
6624         * The shelf-life and storage information for a medicinal product item or container can be described using this class.
6625         */
6626        PRODUCTSHELFLIFE, 
6627        /**
6628         * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
6629         */
6630        QUANTITY, 
6631        /**
6632         * A set of ordered Quantities defined by a low and high limit.
6633         */
6634        RANGE, 
6635        /**
6636         * A relationship of two Quantity values - expressed as a numerator and a denominator.
6637         */
6638        RATIO, 
6639        /**
6640         * A reference from one resource to another.
6641         */
6642        REFERENCE, 
6643        /**
6644         * Related artifacts such as additional documentation, justification, or bibliographic references.
6645         */
6646        RELATEDARTIFACT, 
6647        /**
6648         * A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
6649         */
6650        SAMPLEDDATA, 
6651        /**
6652         * A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
6653         */
6654        SIGNATURE, 
6655        /**
6656         * null
6657         */
6658        SIMPLEQUANTITY, 
6659        /**
6660         * Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.
6661         */
6662        SUBSTANCEAMOUNT, 
6663        /**
6664         * Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
6665         */
6666        TIMING, 
6667        /**
6668         * A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
6669         */
6670        TRIGGERDEFINITION, 
6671        /**
6672         * Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
6673         */
6674        USAGECONTEXT, 
6675        /**
6676         * A stream of bytes
6677         */
6678        BASE64BINARY, 
6679        /**
6680         * Value of "true" or "false"
6681         */
6682        BOOLEAN, 
6683        /**
6684         * A URI that is a reference to a canonical URL on a FHIR resource
6685         */
6686        CANONICAL, 
6687        /**
6688         * A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
6689         */
6690        CODE, 
6691        /**
6692         * A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
6693         */
6694        DATE, 
6695        /**
6696         * A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.
6697         */
6698        DATETIME, 
6699        /**
6700         * A rational number with implicit precision
6701         */
6702        DECIMAL, 
6703        /**
6704         * Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.
6705         */
6706        ID, 
6707        /**
6708         * An instant in time - known at least to the second
6709         */
6710        INSTANT, 
6711        /**
6712         * A whole number
6713         */
6714        INTEGER, 
6715        /**
6716         * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
6717         */
6718        MARKDOWN, 
6719        /**
6720         * An OID represented as a URI
6721         */
6722        OID, 
6723        /**
6724         * An integer with a value that is positive (e.g. >0)
6725         */
6726        POSITIVEINT, 
6727        /**
6728         * A sequence of Unicode characters
6729         */
6730        STRING, 
6731        /**
6732         * A time during the day, with no date specified
6733         */
6734        TIME, 
6735        /**
6736         * An integer with a value that is not negative (e.g. >= 0)
6737         */
6738        UNSIGNEDINT, 
6739        /**
6740         * String of characters used to identify a name or a resource
6741         */
6742        URI, 
6743        /**
6744         * A URI that is a literal reference
6745         */
6746        URL, 
6747        /**
6748         * A UUID, represented as a URI
6749         */
6750        UUID, 
6751        /**
6752         * XHTML format, as defined by W3C, but restricted usage (mainly, no active content)
6753         */
6754        XHTML, 
6755        /**
6756         * A financial tool for tracking value accrued for a particular purpose.  In the healthcare field, used to track charges for a patient, cost centers, etc.
6757         */
6758        ACCOUNT, 
6759        /**
6760         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
6761         */
6762        ACTIVITYDEFINITION, 
6763        /**
6764         * Actual or  potential/avoided event causing unintended physical injury resulting from or contributed to by medical care, a research study or other healthcare setting factors that requires additional monitoring, treatment, or hospitalization, or that results in death.
6765         */
6766        ADVERSEEVENT, 
6767        /**
6768         * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.
6769         */
6770        ALLERGYINTOLERANCE, 
6771        /**
6772         * A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s).
6773         */
6774        APPOINTMENT, 
6775        /**
6776         * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.
6777         */
6778        APPOINTMENTRESPONSE, 
6779        /**
6780         * A record of an event made for purposes of maintaining a security log. Typical uses include detection of intrusion attempts and monitoring for inappropriate usage.
6781         */
6782        AUDITEVENT, 
6783        /**
6784         * Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification.
6785         */
6786        BASIC, 
6787        /**
6788         * A resource that represents the data of a single raw artifact as digital content accessible in its native format.  A Binary resource can contain any content, whether text, image, pdf, zip archive, etc.
6789         */
6790        BINARY, 
6791        /**
6792         * A material substance originating from a biological entity intended to be transplanted or infused
6793into another (possibly the same) biological entity.
6794         */
6795        BIOLOGICALLYDERIVEDPRODUCT, 
6796        /**
6797         * Record details about an anatomical structure.  This resource may be used when a coded concept does not provide the necessary detail needed for the use case.
6798         */
6799        BODYSTRUCTURE, 
6800        /**
6801         * A container for a collection of resources.
6802         */
6803        BUNDLE, 
6804        /**
6805         * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
6806         */
6807        CAPABILITYSTATEMENT, 
6808        /**
6809         * Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions.
6810         */
6811        CAREPLAN, 
6812        /**
6813         * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care for a patient.
6814         */
6815        CARETEAM, 
6816        /**
6817         * Catalog entries are wrappers that contextualize items included in a catalog.
6818         */
6819        CATALOGENTRY, 
6820        /**
6821         * The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation.
6822         */
6823        CHARGEITEM, 
6824        /**
6825         * The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system.
6826         */
6827        CHARGEITEMDEFINITION, 
6828        /**
6829         * A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement.
6830         */
6831        CLAIM, 
6832        /**
6833         * This resource provides the adjudication details from the processing of a Claim resource.
6834         */
6835        CLAIMRESPONSE, 
6836        /**
6837         * A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter,  but this varies greatly depending on the clinical workflow. This resource is called "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with the recording of assessment tools such as Apgar score.
6838         */
6839        CLINICALIMPRESSION, 
6840        /**
6841         * 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.
6842         */
6843        CODESYSTEM, 
6844        /**
6845         * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition.
6846         */
6847        COMMUNICATION, 
6848        /**
6849         * A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition.
6850         */
6851        COMMUNICATIONREQUEST, 
6852        /**
6853         * A compartment definition that defines how resources are accessed on a server.
6854         */
6855        COMPARTMENTDEFINITION, 
6856        /**
6857         * A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.).
6858         */
6859        COMPOSITION, 
6860        /**
6861         * A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models.
6862         */
6863        CONCEPTMAP, 
6864        /**
6865         * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.
6866         */
6867        CONDITION, 
6868        /**
6869         * A record of a healthcare consumer?s  choices, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time.
6870         */
6871        CONSENT, 
6872        /**
6873         * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
6874         */
6875        CONTRACT, 
6876        /**
6877         * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.
6878         */
6879        COVERAGE, 
6880        /**
6881         * The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy.
6882         */
6883        COVERAGEELIGIBILITYREQUEST, 
6884        /**
6885         * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.
6886         */
6887        COVERAGEELIGIBILITYRESPONSE, 
6888        /**
6889         * Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc.
6890         */
6891        DETECTEDISSUE, 
6892        /**
6893         * A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.
6894         */
6895        DEVICE, 
6896        /**
6897         * The characteristics, operational status and capabilities of a medical-related component of a medical device.
6898         */
6899        DEVICEDEFINITION, 
6900        /**
6901         * Describes a measurement, calculation or setting capability of a medical device.
6902         */
6903        DEVICEMETRIC, 
6904        /**
6905         * Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker.
6906         */
6907        DEVICEREQUEST, 
6908        /**
6909         * A record of a device being used by a patient where the record is the result of a report from the patient or another clinician.
6910         */
6911        DEVICEUSESTATEMENT, 
6912        /**
6913         * The findings and interpretation of diagnostic  tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports.
6914         */
6915        DIAGNOSTICREPORT, 
6916        /**
6917         * A collection of documents compiled for a purpose together with metadata that applies to the collection.
6918         */
6919        DOCUMENTMANIFEST, 
6920        /**
6921         * A reference to a document of any kind for any purpose. Provides metadata about the document so that the document can be discovered and managed. The scope of a document is any seralized object with a mime-type, so includes formal patient centric documents (CDA), cliical notes, scanned paper, and non-patient specific documents like policy text.
6922         */
6923        DOCUMENTREFERENCE, 
6924        /**
6925         * A resource that includes narrative, extensions, and contained resources.
6926         */
6927        DOMAINRESOURCE, 
6928        /**
6929         * The EffectEvidenceSynthesis resource describes the difference in an outcome between exposures states in a population where the effect estimate is derived from a combination of research studies.
6930         */
6931        EFFECTEVIDENCESYNTHESIS, 
6932        /**
6933         * An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient.
6934         */
6935        ENCOUNTER, 
6936        /**
6937         * The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information.
6938         */
6939        ENDPOINT, 
6940        /**
6941         * This resource provides the insurance enrollment details to the insurer regarding a specified coverage.
6942         */
6943        ENROLLMENTREQUEST, 
6944        /**
6945         * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.
6946         */
6947        ENROLLMENTRESPONSE, 
6948        /**
6949         * An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time.
6950         */
6951        EPISODEOFCARE, 
6952        /**
6953         * The EventDefinition resource provides a reusable description of when a particular event can occur.
6954         */
6955        EVENTDEFINITION, 
6956        /**
6957         * The Evidence resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.
6958         */
6959        EVIDENCE, 
6960        /**
6961         * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
6962         */
6963        EVIDENCEVARIABLE, 
6964        /**
6965         * Example of workflow instance.
6966         */
6967        EXAMPLESCENARIO, 
6968        /**
6969         * This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided.
6970         */
6971        EXPLANATIONOFBENEFIT, 
6972        /**
6973         * Significant health conditions for a person related to the patient relevant in the context of care for the patient.
6974         */
6975        FAMILYMEMBERHISTORY, 
6976        /**
6977         * Prospective warnings of potential issues when providing care to the patient.
6978         */
6979        FLAG, 
6980        /**
6981         * Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.
6982         */
6983        GOAL, 
6984        /**
6985         * A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set.
6986         */
6987        GRAPHDEFINITION, 
6988        /**
6989         * Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization.
6990         */
6991        GROUP, 
6992        /**
6993         * A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken.
6994         */
6995        GUIDANCERESPONSE, 
6996        /**
6997         * The details of a healthcare service available at a location.
6998         */
6999        HEALTHCARESERVICE, 
7000        /**
7001         * Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context.  A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities.
7002         */
7003        IMAGINGSTUDY, 
7004        /**
7005         * Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party.
7006         */
7007        IMMUNIZATION, 
7008        /**
7009         * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations.
7010         */
7011        IMMUNIZATIONEVALUATION, 
7012        /**
7013         * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.
7014         */
7015        IMMUNIZATIONRECOMMENDATION, 
7016        /**
7017         * A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts.
7018         */
7019        IMPLEMENTATIONGUIDE, 
7020        /**
7021         * Details of a Health Insurance product/plan provided by an organization.
7022         */
7023        INSURANCEPLAN, 
7024        /**
7025         * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.
7026         */
7027        INVOICE, 
7028        /**
7029         * The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets.
7030         */
7031        LIBRARY, 
7032        /**
7033         * Identifies two or more records (resource instances) that refer to the same real-world "occurrence".
7034         */
7035        LINKAGE, 
7036        /**
7037         * A list is a curated collection of resources.
7038         */
7039        LIST, 
7040        /**
7041         * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.
7042         */
7043        LOCATION, 
7044        /**
7045         * The Measure resource provides the definition of a quality measure.
7046         */
7047        MEASURE, 
7048        /**
7049         * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.
7050         */
7051        MEASUREREPORT, 
7052        /**
7053         * A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.
7054         */
7055        MEDIA, 
7056        /**
7057         * This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use.
7058         */
7059        MEDICATION, 
7060        /**
7061         * Describes the event of a patient consuming or otherwise being administered a medication.  This may be as simple as swallowing a tablet or it may be a long running infusion.  Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner.
7062         */
7063        MEDICATIONADMINISTRATION, 
7064        /**
7065         * Indicates that a medication product is to be or has been dispensed for a named person/patient.  This includes a description of the medication product (supply) provided and the instructions for administering the medication.  The medication dispense is the result of a pharmacy system responding to a medication order.
7066         */
7067        MEDICATIONDISPENSE, 
7068        /**
7069         * Information about a medication that is used to support knowledge.
7070         */
7071        MEDICATIONKNOWLEDGE, 
7072        /**
7073         * An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called "MedicationRequest" rather than "MedicationPrescription" or "MedicationOrder" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns.
7074         */
7075        MEDICATIONREQUEST, 
7076        /**
7077         * A record of a medication that is being consumed by a patient.   A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future.  The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician.  A common scenario where this information is captured is during the history taking process during a patient visit or stay.   The medication information may come from sources such as the patient's memory, from a prescription bottle,  or from a list of medications the patient, clinician or other party maintains. 
7078
7079The primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medication statement is often, if not always, less specific.  There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise.  As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains.  Medication administration is more formal and is not missing detailed information.
7080         */
7081        MEDICATIONSTATEMENT, 
7082        /**
7083         * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).
7084         */
7085        MEDICINALPRODUCT, 
7086        /**
7087         * The regulatory authorization of a medicinal product.
7088         */
7089        MEDICINALPRODUCTAUTHORIZATION, 
7090        /**
7091         * The clinical particulars - indications, contraindications etc. of a medicinal product, including for regulatory purposes.
7092         */
7093        MEDICINALPRODUCTCONTRAINDICATION, 
7094        /**
7095         * Indication for the Medicinal Product.
7096         */
7097        MEDICINALPRODUCTINDICATION, 
7098        /**
7099         * An ingredient of a manufactured item or pharmaceutical product.
7100         */
7101        MEDICINALPRODUCTINGREDIENT, 
7102        /**
7103         * The interactions of the medicinal product with other medicinal products, or other forms of interactions.
7104         */
7105        MEDICINALPRODUCTINTERACTION, 
7106        /**
7107         * The manufactured item as contained in the packaged medicinal product.
7108         */
7109        MEDICINALPRODUCTMANUFACTURED, 
7110        /**
7111         * A medicinal product in a container or package.
7112         */
7113        MEDICINALPRODUCTPACKAGED, 
7114        /**
7115         * A pharmaceutical product described in terms of its composition and dose form.
7116         */
7117        MEDICINALPRODUCTPHARMACEUTICAL, 
7118        /**
7119         * Describe the undesirable effects of the medicinal product.
7120         */
7121        MEDICINALPRODUCTUNDESIRABLEEFFECT, 
7122        /**
7123         * Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted.
7124         */
7125        MESSAGEDEFINITION, 
7126        /**
7127         * The header for a message exchange that is either requesting or responding to an action.  The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle.
7128         */
7129        MESSAGEHEADER, 
7130        /**
7131         * Raw data describing a biological sequence.
7132         */
7133        MOLECULARSEQUENCE, 
7134        /**
7135         * A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc.  Represents a "System" used within the Identifier and Coding data types.
7136         */
7137        NAMINGSYSTEM, 
7138        /**
7139         * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.
7140         */
7141        NUTRITIONORDER, 
7142        /**
7143         * Measurements and simple assertions made about a patient, device or other subject.
7144         */
7145        OBSERVATION, 
7146        /**
7147         * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.
7148         */
7149        OBSERVATIONDEFINITION, 
7150        /**
7151         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
7152         */
7153        OPERATIONDEFINITION, 
7154        /**
7155         * A collection of error, warning, or information messages that result from a system action.
7156         */
7157        OPERATIONOUTCOME, 
7158        /**
7159         * A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action.  Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc.
7160         */
7161        ORGANIZATION, 
7162        /**
7163         * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.
7164         */
7165        ORGANIZATIONAFFILIATION, 
7166        /**
7167         * This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it.
7168         */
7169        PARAMETERS, 
7170        /**
7171         * Demographics and other administrative information about an individual or animal receiving care or other health-related services.
7172         */
7173        PATIENT, 
7174        /**
7175         * This resource provides the status of the payment for goods and services rendered, and the request and response resource references.
7176         */
7177        PAYMENTNOTICE, 
7178        /**
7179         * This resource provides the details including amount of a payment and allocates the payment items being paid.
7180         */
7181        PAYMENTRECONCILIATION, 
7182        /**
7183         * Demographics and administrative information about a person independent of a specific health-related context.
7184         */
7185        PERSON, 
7186        /**
7187         * This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.
7188         */
7189        PLANDEFINITION, 
7190        /**
7191         * A person who is directly or indirectly involved in the provisioning of healthcare.
7192         */
7193        PRACTITIONER, 
7194        /**
7195         * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.
7196         */
7197        PRACTITIONERROLE, 
7198        /**
7199         * An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy.
7200         */
7201        PROCEDURE, 
7202        /**
7203         * Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies.
7204         */
7205        PROVENANCE, 
7206        /**
7207         * A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.
7208         */
7209        QUESTIONNAIRE, 
7210        /**
7211         * A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to.
7212         */
7213        QUESTIONNAIRERESPONSE, 
7214        /**
7215         * Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.
7216         */
7217        RELATEDPERSON, 
7218        /**
7219         * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one".
7220         */
7221        REQUESTGROUP, 
7222        /**
7223         * The ResearchDefinition resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.
7224         */
7225        RESEARCHDEFINITION, 
7226        /**
7227         * The ResearchElementDefinition resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
7228         */
7229        RESEARCHELEMENTDEFINITION, 
7230        /**
7231         * A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge.  This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques.  A ResearchStudy involves the gathering of information about human or animal subjects.
7232         */
7233        RESEARCHSTUDY, 
7234        /**
7235         * A physical entity which is the primary unit of operational and/or administrative interest in a study.
7236         */
7237        RESEARCHSUBJECT, 
7238        /**
7239         * This is the base resource type for everything.
7240         */
7241        RESOURCE, 
7242        /**
7243         * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.
7244         */
7245        RISKASSESSMENT, 
7246        /**
7247         * The RiskEvidenceSynthesis resource describes the likelihood of an outcome in a population plus exposure state where the risk estimate is derived from a combination of research studies.
7248         */
7249        RISKEVIDENCESYNTHESIS, 
7250        /**
7251         * A container for slots of time that may be available for booking appointments.
7252         */
7253        SCHEDULE, 
7254        /**
7255         * A search parameter that defines a named search item that can be used to search/filter on a resource.
7256         */
7257        SEARCHPARAMETER, 
7258        /**
7259         * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.
7260         */
7261        SERVICEREQUEST, 
7262        /**
7263         * A slot of time on a schedule that may be available for booking appointments.
7264         */
7265        SLOT, 
7266        /**
7267         * A sample to be used for analysis.
7268         */
7269        SPECIMEN, 
7270        /**
7271         * A kind of specimen with associated set of requirements.
7272         */
7273        SPECIMENDEFINITION, 
7274        /**
7275         * A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.
7276         */
7277        STRUCTUREDEFINITION, 
7278        /**
7279         * A Map of relationships between 2 structures that can be used to transform data.
7280         */
7281        STRUCTUREMAP, 
7282        /**
7283         * The subscription resource is used to define a push-based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined "channel" so that another system can take an appropriate action.
7284         */
7285        SUBSCRIPTION, 
7286        /**
7287         * A homogeneous material with a definite composition.
7288         */
7289        SUBSTANCE, 
7290        /**
7291         * Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction.
7292         */
7293        SUBSTANCENUCLEICACID, 
7294        /**
7295         * Todo.
7296         */
7297        SUBSTANCEPOLYMER, 
7298        /**
7299         * A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators.
7300         */
7301        SUBSTANCEPROTEIN, 
7302        /**
7303         * Todo.
7304         */
7305        SUBSTANCEREFERENCEINFORMATION, 
7306        /**
7307         * Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex.
7308         */
7309        SUBSTANCESOURCEMATERIAL, 
7310        /**
7311         * The detailed description of a substance, typically at a level beyond what is used for prescribing.
7312         */
7313        SUBSTANCESPECIFICATION, 
7314        /**
7315         * Record of delivery of what is supplied.
7316         */
7317        SUPPLYDELIVERY, 
7318        /**
7319         * A record of a request for a medication, substance or device used in the healthcare setting.
7320         */
7321        SUPPLYREQUEST, 
7322        /**
7323         * A task to be performed.
7324         */
7325        TASK, 
7326        /**
7327         * A Terminology Capabilities documents a set of capabilities (behaviors) of a FHIR Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
7328         */
7329        TERMINOLOGYCAPABILITIES, 
7330        /**
7331         * A summary of information based on the results of executing a TestScript.
7332         */
7333        TESTREPORT, 
7334        /**
7335         * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
7336         */
7337        TESTSCRIPT, 
7338        /**
7339         * A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).
7340         */
7341        VALUESET, 
7342        /**
7343         * Describes validation requirements, source(s), status and dates for one or more elements.
7344         */
7345        VERIFICATIONRESULT, 
7346        /**
7347         * An authorization for the provision of glasses and/or contact lenses to a patient.
7348         */
7349        VISIONPRESCRIPTION, 
7350        /**
7351         * added to help the parsers
7352         */
7353        NULL;
7354        public static FHIRDefinedType fromCode(String codeString) throws FHIRException {
7355            if (codeString == null || "".equals(codeString))
7356                return null;
7357        if ("Address".equals(codeString))
7358          return ADDRESS;
7359        if ("Age".equals(codeString))
7360          return AGE;
7361        if ("Annotation".equals(codeString))
7362          return ANNOTATION;
7363        if ("Attachment".equals(codeString))
7364          return ATTACHMENT;
7365        if ("BackboneElement".equals(codeString))
7366          return BACKBONEELEMENT;
7367        if ("CodeableConcept".equals(codeString))
7368          return CODEABLECONCEPT;
7369        if ("Coding".equals(codeString))
7370          return CODING;
7371        if ("ContactDetail".equals(codeString))
7372          return CONTACTDETAIL;
7373        if ("ContactPoint".equals(codeString))
7374          return CONTACTPOINT;
7375        if ("Contributor".equals(codeString))
7376          return CONTRIBUTOR;
7377        if ("Count".equals(codeString))
7378          return COUNT;
7379        if ("DataRequirement".equals(codeString))
7380          return DATAREQUIREMENT;
7381        if ("Distance".equals(codeString))
7382          return DISTANCE;
7383        if ("Dosage".equals(codeString))
7384          return DOSAGE;
7385        if ("Duration".equals(codeString))
7386          return DURATION;
7387        if ("Element".equals(codeString))
7388          return ELEMENT;
7389        if ("ElementDefinition".equals(codeString))
7390          return ELEMENTDEFINITION;
7391        if ("Expression".equals(codeString))
7392          return EXPRESSION;
7393        if ("Extension".equals(codeString))
7394          return EXTENSION;
7395        if ("HumanName".equals(codeString))
7396          return HUMANNAME;
7397        if ("Identifier".equals(codeString))
7398          return IDENTIFIER;
7399        if ("MarketingStatus".equals(codeString))
7400          return MARKETINGSTATUS;
7401        if ("Meta".equals(codeString))
7402          return META;
7403        if ("Money".equals(codeString))
7404          return MONEY;
7405        if ("MoneyQuantity".equals(codeString))
7406          return MONEYQUANTITY;
7407        if ("Narrative".equals(codeString))
7408          return NARRATIVE;
7409        if ("ParameterDefinition".equals(codeString))
7410          return PARAMETERDEFINITION;
7411        if ("Period".equals(codeString))
7412          return PERIOD;
7413        if ("Population".equals(codeString))
7414          return POPULATION;
7415        if ("ProdCharacteristic".equals(codeString))
7416          return PRODCHARACTERISTIC;
7417        if ("ProductShelfLife".equals(codeString))
7418          return PRODUCTSHELFLIFE;
7419        if ("Quantity".equals(codeString))
7420          return QUANTITY;
7421        if ("Range".equals(codeString))
7422          return RANGE;
7423        if ("Ratio".equals(codeString))
7424          return RATIO;
7425        if ("Reference".equals(codeString))
7426          return REFERENCE;
7427        if ("RelatedArtifact".equals(codeString))
7428          return RELATEDARTIFACT;
7429        if ("SampledData".equals(codeString))
7430          return SAMPLEDDATA;
7431        if ("Signature".equals(codeString))
7432          return SIGNATURE;
7433        if ("SimpleQuantity".equals(codeString))
7434          return SIMPLEQUANTITY;
7435        if ("SubstanceAmount".equals(codeString))
7436          return SUBSTANCEAMOUNT;
7437        if ("Timing".equals(codeString))
7438          return TIMING;
7439        if ("TriggerDefinition".equals(codeString))
7440          return TRIGGERDEFINITION;
7441        if ("UsageContext".equals(codeString))
7442          return USAGECONTEXT;
7443        if ("base64Binary".equals(codeString))
7444          return BASE64BINARY;
7445        if ("boolean".equals(codeString))
7446          return BOOLEAN;
7447        if ("canonical".equals(codeString))
7448          return CANONICAL;
7449        if ("code".equals(codeString))
7450          return CODE;
7451        if ("date".equals(codeString))
7452          return DATE;
7453        if ("dateTime".equals(codeString))
7454          return DATETIME;
7455        if ("decimal".equals(codeString))
7456          return DECIMAL;
7457        if ("id".equals(codeString))
7458          return ID;
7459        if ("instant".equals(codeString))
7460          return INSTANT;
7461        if ("integer".equals(codeString))
7462          return INTEGER;
7463        if ("markdown".equals(codeString))
7464          return MARKDOWN;
7465        if ("oid".equals(codeString))
7466          return OID;
7467        if ("positiveInt".equals(codeString))
7468          return POSITIVEINT;
7469        if ("string".equals(codeString))
7470          return STRING;
7471        if ("time".equals(codeString))
7472          return TIME;
7473        if ("unsignedInt".equals(codeString))
7474          return UNSIGNEDINT;
7475        if ("uri".equals(codeString))
7476          return URI;
7477        if ("url".equals(codeString))
7478          return URL;
7479        if ("uuid".equals(codeString))
7480          return UUID;
7481        if ("xhtml".equals(codeString))
7482          return XHTML;
7483        if ("Account".equals(codeString))
7484          return ACCOUNT;
7485        if ("ActivityDefinition".equals(codeString))
7486          return ACTIVITYDEFINITION;
7487        if ("AdverseEvent".equals(codeString))
7488          return ADVERSEEVENT;
7489        if ("AllergyIntolerance".equals(codeString))
7490          return ALLERGYINTOLERANCE;
7491        if ("Appointment".equals(codeString))
7492          return APPOINTMENT;
7493        if ("AppointmentResponse".equals(codeString))
7494          return APPOINTMENTRESPONSE;
7495        if ("AuditEvent".equals(codeString))
7496          return AUDITEVENT;
7497        if ("Basic".equals(codeString))
7498          return BASIC;
7499        if ("Binary".equals(codeString))
7500          return BINARY;
7501        if ("BiologicallyDerivedProduct".equals(codeString))
7502          return BIOLOGICALLYDERIVEDPRODUCT;
7503        if ("BodyStructure".equals(codeString))
7504          return BODYSTRUCTURE;
7505        if ("Bundle".equals(codeString))
7506          return BUNDLE;
7507        if ("CapabilityStatement".equals(codeString))
7508          return CAPABILITYSTATEMENT;
7509        if ("CarePlan".equals(codeString))
7510          return CAREPLAN;
7511        if ("CareTeam".equals(codeString))
7512          return CARETEAM;
7513        if ("CatalogEntry".equals(codeString))
7514          return CATALOGENTRY;
7515        if ("ChargeItem".equals(codeString))
7516          return CHARGEITEM;
7517        if ("ChargeItemDefinition".equals(codeString))
7518          return CHARGEITEMDEFINITION;
7519        if ("Claim".equals(codeString))
7520          return CLAIM;
7521        if ("ClaimResponse".equals(codeString))
7522          return CLAIMRESPONSE;
7523        if ("ClinicalImpression".equals(codeString))
7524          return CLINICALIMPRESSION;
7525        if ("CodeSystem".equals(codeString))
7526          return CODESYSTEM;
7527        if ("Communication".equals(codeString))
7528          return COMMUNICATION;
7529        if ("CommunicationRequest".equals(codeString))
7530          return COMMUNICATIONREQUEST;
7531        if ("CompartmentDefinition".equals(codeString))
7532          return COMPARTMENTDEFINITION;
7533        if ("Composition".equals(codeString))
7534          return COMPOSITION;
7535        if ("ConceptMap".equals(codeString))
7536          return CONCEPTMAP;
7537        if ("Condition".equals(codeString))
7538          return CONDITION;
7539        if ("Consent".equals(codeString))
7540          return CONSENT;
7541        if ("Contract".equals(codeString))
7542          return CONTRACT;
7543        if ("Coverage".equals(codeString))
7544          return COVERAGE;
7545        if ("CoverageEligibilityRequest".equals(codeString))
7546          return COVERAGEELIGIBILITYREQUEST;
7547        if ("CoverageEligibilityResponse".equals(codeString))
7548          return COVERAGEELIGIBILITYRESPONSE;
7549        if ("DetectedIssue".equals(codeString))
7550          return DETECTEDISSUE;
7551        if ("Device".equals(codeString))
7552          return DEVICE;
7553        if ("DeviceDefinition".equals(codeString))
7554          return DEVICEDEFINITION;
7555        if ("DeviceMetric".equals(codeString))
7556          return DEVICEMETRIC;
7557        if ("DeviceRequest".equals(codeString))
7558          return DEVICEREQUEST;
7559        if ("DeviceUseStatement".equals(codeString))
7560          return DEVICEUSESTATEMENT;
7561        if ("DiagnosticReport".equals(codeString))
7562          return DIAGNOSTICREPORT;
7563        if ("DocumentManifest".equals(codeString))
7564          return DOCUMENTMANIFEST;
7565        if ("DocumentReference".equals(codeString))
7566          return DOCUMENTREFERENCE;
7567        if ("DomainResource".equals(codeString))
7568          return DOMAINRESOURCE;
7569        if ("EffectEvidenceSynthesis".equals(codeString))
7570          return EFFECTEVIDENCESYNTHESIS;
7571        if ("Encounter".equals(codeString))
7572          return ENCOUNTER;
7573        if ("Endpoint".equals(codeString))
7574          return ENDPOINT;
7575        if ("EnrollmentRequest".equals(codeString))
7576          return ENROLLMENTREQUEST;
7577        if ("EnrollmentResponse".equals(codeString))
7578          return ENROLLMENTRESPONSE;
7579        if ("EpisodeOfCare".equals(codeString))
7580          return EPISODEOFCARE;
7581        if ("EventDefinition".equals(codeString))
7582          return EVENTDEFINITION;
7583        if ("Evidence".equals(codeString))
7584          return EVIDENCE;
7585        if ("EvidenceVariable".equals(codeString))
7586          return EVIDENCEVARIABLE;
7587        if ("ExampleScenario".equals(codeString))
7588          return EXAMPLESCENARIO;
7589        if ("ExplanationOfBenefit".equals(codeString))
7590          return EXPLANATIONOFBENEFIT;
7591        if ("FamilyMemberHistory".equals(codeString))
7592          return FAMILYMEMBERHISTORY;
7593        if ("Flag".equals(codeString))
7594          return FLAG;
7595        if ("Goal".equals(codeString))
7596          return GOAL;
7597        if ("GraphDefinition".equals(codeString))
7598          return GRAPHDEFINITION;
7599        if ("Group".equals(codeString))
7600          return GROUP;
7601        if ("GuidanceResponse".equals(codeString))
7602          return GUIDANCERESPONSE;
7603        if ("HealthcareService".equals(codeString))
7604          return HEALTHCARESERVICE;
7605        if ("ImagingStudy".equals(codeString))
7606          return IMAGINGSTUDY;
7607        if ("Immunization".equals(codeString))
7608          return IMMUNIZATION;
7609        if ("ImmunizationEvaluation".equals(codeString))
7610          return IMMUNIZATIONEVALUATION;
7611        if ("ImmunizationRecommendation".equals(codeString))
7612          return IMMUNIZATIONRECOMMENDATION;
7613        if ("ImplementationGuide".equals(codeString))
7614          return IMPLEMENTATIONGUIDE;
7615        if ("InsurancePlan".equals(codeString))
7616          return INSURANCEPLAN;
7617        if ("Invoice".equals(codeString))
7618          return INVOICE;
7619        if ("Library".equals(codeString))
7620          return LIBRARY;
7621        if ("Linkage".equals(codeString))
7622          return LINKAGE;
7623        if ("List".equals(codeString))
7624          return LIST;
7625        if ("Location".equals(codeString))
7626          return LOCATION;
7627        if ("Measure".equals(codeString))
7628          return MEASURE;
7629        if ("MeasureReport".equals(codeString))
7630          return MEASUREREPORT;
7631        if ("Media".equals(codeString))
7632          return MEDIA;
7633        if ("Medication".equals(codeString))
7634          return MEDICATION;
7635        if ("MedicationAdministration".equals(codeString))
7636          return MEDICATIONADMINISTRATION;
7637        if ("MedicationDispense".equals(codeString))
7638          return MEDICATIONDISPENSE;
7639        if ("MedicationKnowledge".equals(codeString))
7640          return MEDICATIONKNOWLEDGE;
7641        if ("MedicationRequest".equals(codeString))
7642          return MEDICATIONREQUEST;
7643        if ("MedicationStatement".equals(codeString))
7644          return MEDICATIONSTATEMENT;
7645        if ("MedicinalProduct".equals(codeString))
7646          return MEDICINALPRODUCT;
7647        if ("MedicinalProductAuthorization".equals(codeString))
7648          return MEDICINALPRODUCTAUTHORIZATION;
7649        if ("MedicinalProductContraindication".equals(codeString))
7650          return MEDICINALPRODUCTCONTRAINDICATION;
7651        if ("MedicinalProductIndication".equals(codeString))
7652          return MEDICINALPRODUCTINDICATION;
7653        if ("MedicinalProductIngredient".equals(codeString))
7654          return MEDICINALPRODUCTINGREDIENT;
7655        if ("MedicinalProductInteraction".equals(codeString))
7656          return MEDICINALPRODUCTINTERACTION;
7657        if ("MedicinalProductManufactured".equals(codeString))
7658          return MEDICINALPRODUCTMANUFACTURED;
7659        if ("MedicinalProductPackaged".equals(codeString))
7660          return MEDICINALPRODUCTPACKAGED;
7661        if ("MedicinalProductPharmaceutical".equals(codeString))
7662          return MEDICINALPRODUCTPHARMACEUTICAL;
7663        if ("MedicinalProductUndesirableEffect".equals(codeString))
7664          return MEDICINALPRODUCTUNDESIRABLEEFFECT;
7665        if ("MessageDefinition".equals(codeString))
7666          return MESSAGEDEFINITION;
7667        if ("MessageHeader".equals(codeString))
7668          return MESSAGEHEADER;
7669        if ("MolecularSequence".equals(codeString))
7670          return MOLECULARSEQUENCE;
7671        if ("NamingSystem".equals(codeString))
7672          return NAMINGSYSTEM;
7673        if ("NutritionOrder".equals(codeString))
7674          return NUTRITIONORDER;
7675        if ("Observation".equals(codeString))
7676          return OBSERVATION;
7677        if ("ObservationDefinition".equals(codeString))
7678          return OBSERVATIONDEFINITION;
7679        if ("OperationDefinition".equals(codeString))
7680          return OPERATIONDEFINITION;
7681        if ("OperationOutcome".equals(codeString))
7682          return OPERATIONOUTCOME;
7683        if ("Organization".equals(codeString))
7684          return ORGANIZATION;
7685        if ("OrganizationAffiliation".equals(codeString))
7686          return ORGANIZATIONAFFILIATION;
7687        if ("Parameters".equals(codeString))
7688          return PARAMETERS;
7689        if ("Patient".equals(codeString))
7690          return PATIENT;
7691        if ("PaymentNotice".equals(codeString))
7692          return PAYMENTNOTICE;
7693        if ("PaymentReconciliation".equals(codeString))
7694          return PAYMENTRECONCILIATION;
7695        if ("Person".equals(codeString))
7696          return PERSON;
7697        if ("PlanDefinition".equals(codeString))
7698          return PLANDEFINITION;
7699        if ("Practitioner".equals(codeString))
7700          return PRACTITIONER;
7701        if ("PractitionerRole".equals(codeString))
7702          return PRACTITIONERROLE;
7703        if ("Procedure".equals(codeString))
7704          return PROCEDURE;
7705        if ("Provenance".equals(codeString))
7706          return PROVENANCE;
7707        if ("Questionnaire".equals(codeString))
7708          return QUESTIONNAIRE;
7709        if ("QuestionnaireResponse".equals(codeString))
7710          return QUESTIONNAIRERESPONSE;
7711        if ("RelatedPerson".equals(codeString))
7712          return RELATEDPERSON;
7713        if ("RequestGroup".equals(codeString))
7714          return REQUESTGROUP;
7715        if ("ResearchDefinition".equals(codeString))
7716          return RESEARCHDEFINITION;
7717        if ("ResearchElementDefinition".equals(codeString))
7718          return RESEARCHELEMENTDEFINITION;
7719        if ("ResearchStudy".equals(codeString))
7720          return RESEARCHSTUDY;
7721        if ("ResearchSubject".equals(codeString))
7722          return RESEARCHSUBJECT;
7723        if ("Resource".equals(codeString))
7724          return RESOURCE;
7725        if ("RiskAssessment".equals(codeString))
7726          return RISKASSESSMENT;
7727        if ("RiskEvidenceSynthesis".equals(codeString))
7728          return RISKEVIDENCESYNTHESIS;
7729        if ("Schedule".equals(codeString))
7730          return SCHEDULE;
7731        if ("SearchParameter".equals(codeString))
7732          return SEARCHPARAMETER;
7733        if ("ServiceRequest".equals(codeString))
7734          return SERVICEREQUEST;
7735        if ("Slot".equals(codeString))
7736          return SLOT;
7737        if ("Specimen".equals(codeString))
7738          return SPECIMEN;
7739        if ("SpecimenDefinition".equals(codeString))
7740          return SPECIMENDEFINITION;
7741        if ("StructureDefinition".equals(codeString))
7742          return STRUCTUREDEFINITION;
7743        if ("StructureMap".equals(codeString))
7744          return STRUCTUREMAP;
7745        if ("Subscription".equals(codeString))
7746          return SUBSCRIPTION;
7747        if ("Substance".equals(codeString))
7748          return SUBSTANCE;
7749        if ("SubstanceNucleicAcid".equals(codeString))
7750          return SUBSTANCENUCLEICACID;
7751        if ("SubstancePolymer".equals(codeString))
7752          return SUBSTANCEPOLYMER;
7753        if ("SubstanceProtein".equals(codeString))
7754          return SUBSTANCEPROTEIN;
7755        if ("SubstanceReferenceInformation".equals(codeString))
7756          return SUBSTANCEREFERENCEINFORMATION;
7757        if ("SubstanceSourceMaterial".equals(codeString))
7758          return SUBSTANCESOURCEMATERIAL;
7759        if ("SubstanceSpecification".equals(codeString))
7760          return SUBSTANCESPECIFICATION;
7761        if ("SupplyDelivery".equals(codeString))
7762          return SUPPLYDELIVERY;
7763        if ("SupplyRequest".equals(codeString))
7764          return SUPPLYREQUEST;
7765        if ("Task".equals(codeString))
7766          return TASK;
7767        if ("TerminologyCapabilities".equals(codeString))
7768          return TERMINOLOGYCAPABILITIES;
7769        if ("TestReport".equals(codeString))
7770          return TESTREPORT;
7771        if ("TestScript".equals(codeString))
7772          return TESTSCRIPT;
7773        if ("ValueSet".equals(codeString))
7774          return VALUESET;
7775        if ("VerificationResult".equals(codeString))
7776          return VERIFICATIONRESULT;
7777        if ("VisionPrescription".equals(codeString))
7778          return VISIONPRESCRIPTION;
7779        throw new FHIRException("Unknown FHIRDefinedType code '"+codeString+"'");
7780        }
7781        public String toCode() {
7782          switch (this) {
7783            case ADDRESS: return "Address";
7784            case AGE: return "Age";
7785            case ANNOTATION: return "Annotation";
7786            case ATTACHMENT: return "Attachment";
7787            case BACKBONEELEMENT: return "BackboneElement";
7788            case CODEABLECONCEPT: return "CodeableConcept";
7789            case CODING: return "Coding";
7790            case CONTACTDETAIL: return "ContactDetail";
7791            case CONTACTPOINT: return "ContactPoint";
7792            case CONTRIBUTOR: return "Contributor";
7793            case COUNT: return "Count";
7794            case DATAREQUIREMENT: return "DataRequirement";
7795            case DISTANCE: return "Distance";
7796            case DOSAGE: return "Dosage";
7797            case DURATION: return "Duration";
7798            case ELEMENT: return "Element";
7799            case ELEMENTDEFINITION: return "ElementDefinition";
7800            case EXPRESSION: return "Expression";
7801            case EXTENSION: return "Extension";
7802            case HUMANNAME: return "HumanName";
7803            case IDENTIFIER: return "Identifier";
7804            case MARKETINGSTATUS: return "MarketingStatus";
7805            case META: return "Meta";
7806            case MONEY: return "Money";
7807            case MONEYQUANTITY: return "MoneyQuantity";
7808            case NARRATIVE: return "Narrative";
7809            case PARAMETERDEFINITION: return "ParameterDefinition";
7810            case PERIOD: return "Period";
7811            case POPULATION: return "Population";
7812            case PRODCHARACTERISTIC: return "ProdCharacteristic";
7813            case PRODUCTSHELFLIFE: return "ProductShelfLife";
7814            case QUANTITY: return "Quantity";
7815            case RANGE: return "Range";
7816            case RATIO: return "Ratio";
7817            case REFERENCE: return "Reference";
7818            case RELATEDARTIFACT: return "RelatedArtifact";
7819            case SAMPLEDDATA: return "SampledData";
7820            case SIGNATURE: return "Signature";
7821            case SIMPLEQUANTITY: return "SimpleQuantity";
7822            case SUBSTANCEAMOUNT: return "SubstanceAmount";
7823            case TIMING: return "Timing";
7824            case TRIGGERDEFINITION: return "TriggerDefinition";
7825            case USAGECONTEXT: return "UsageContext";
7826            case BASE64BINARY: return "base64Binary";
7827            case BOOLEAN: return "boolean";
7828            case CANONICAL: return "canonical";
7829            case CODE: return "code";
7830            case DATE: return "date";
7831            case DATETIME: return "dateTime";
7832            case DECIMAL: return "decimal";
7833            case ID: return "id";
7834            case INSTANT: return "instant";
7835            case INTEGER: return "integer";
7836            case MARKDOWN: return "markdown";
7837            case OID: return "oid";
7838            case POSITIVEINT: return "positiveInt";
7839            case STRING: return "string";
7840            case TIME: return "time";
7841            case UNSIGNEDINT: return "unsignedInt";
7842            case URI: return "uri";
7843            case URL: return "url";
7844            case UUID: return "uuid";
7845            case XHTML: return "xhtml";
7846            case ACCOUNT: return "Account";
7847            case ACTIVITYDEFINITION: return "ActivityDefinition";
7848            case ADVERSEEVENT: return "AdverseEvent";
7849            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
7850            case APPOINTMENT: return "Appointment";
7851            case APPOINTMENTRESPONSE: return "AppointmentResponse";
7852            case AUDITEVENT: return "AuditEvent";
7853            case BASIC: return "Basic";
7854            case BINARY: return "Binary";
7855            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
7856            case BODYSTRUCTURE: return "BodyStructure";
7857            case BUNDLE: return "Bundle";
7858            case CAPABILITYSTATEMENT: return "CapabilityStatement";
7859            case CAREPLAN: return "CarePlan";
7860            case CARETEAM: return "CareTeam";
7861            case CATALOGENTRY: return "CatalogEntry";
7862            case CHARGEITEM: return "ChargeItem";
7863            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
7864            case CLAIM: return "Claim";
7865            case CLAIMRESPONSE: return "ClaimResponse";
7866            case CLINICALIMPRESSION: return "ClinicalImpression";
7867            case CODESYSTEM: return "CodeSystem";
7868            case COMMUNICATION: return "Communication";
7869            case COMMUNICATIONREQUEST: return "CommunicationRequest";
7870            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
7871            case COMPOSITION: return "Composition";
7872            case CONCEPTMAP: return "ConceptMap";
7873            case CONDITION: return "Condition";
7874            case CONSENT: return "Consent";
7875            case CONTRACT: return "Contract";
7876            case COVERAGE: return "Coverage";
7877            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
7878            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
7879            case DETECTEDISSUE: return "DetectedIssue";
7880            case DEVICE: return "Device";
7881            case DEVICEDEFINITION: return "DeviceDefinition";
7882            case DEVICEMETRIC: return "DeviceMetric";
7883            case DEVICEREQUEST: return "DeviceRequest";
7884            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
7885            case DIAGNOSTICREPORT: return "DiagnosticReport";
7886            case DOCUMENTMANIFEST: return "DocumentManifest";
7887            case DOCUMENTREFERENCE: return "DocumentReference";
7888            case DOMAINRESOURCE: return "DomainResource";
7889            case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis";
7890            case ENCOUNTER: return "Encounter";
7891            case ENDPOINT: return "Endpoint";
7892            case ENROLLMENTREQUEST: return "EnrollmentRequest";
7893            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
7894            case EPISODEOFCARE: return "EpisodeOfCare";
7895            case EVENTDEFINITION: return "EventDefinition";
7896            case EVIDENCE: return "Evidence";
7897            case EVIDENCEVARIABLE: return "EvidenceVariable";
7898            case EXAMPLESCENARIO: return "ExampleScenario";
7899            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
7900            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
7901            case FLAG: return "Flag";
7902            case GOAL: return "Goal";
7903            case GRAPHDEFINITION: return "GraphDefinition";
7904            case GROUP: return "Group";
7905            case GUIDANCERESPONSE: return "GuidanceResponse";
7906            case HEALTHCARESERVICE: return "HealthcareService";
7907            case IMAGINGSTUDY: return "ImagingStudy";
7908            case IMMUNIZATION: return "Immunization";
7909            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
7910            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
7911            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
7912            case INSURANCEPLAN: return "InsurancePlan";
7913            case INVOICE: return "Invoice";
7914            case LIBRARY: return "Library";
7915            case LINKAGE: return "Linkage";
7916            case LIST: return "List";
7917            case LOCATION: return "Location";
7918            case MEASURE: return "Measure";
7919            case MEASUREREPORT: return "MeasureReport";
7920            case MEDIA: return "Media";
7921            case MEDICATION: return "Medication";
7922            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
7923            case MEDICATIONDISPENSE: return "MedicationDispense";
7924            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
7925            case MEDICATIONREQUEST: return "MedicationRequest";
7926            case MEDICATIONSTATEMENT: return "MedicationStatement";
7927            case MEDICINALPRODUCT: return "MedicinalProduct";
7928            case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization";
7929            case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication";
7930            case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication";
7931            case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient";
7932            case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction";
7933            case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured";
7934            case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged";
7935            case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical";
7936            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect";
7937            case MESSAGEDEFINITION: return "MessageDefinition";
7938            case MESSAGEHEADER: return "MessageHeader";
7939            case MOLECULARSEQUENCE: return "MolecularSequence";
7940            case NAMINGSYSTEM: return "NamingSystem";
7941            case NUTRITIONORDER: return "NutritionOrder";
7942            case OBSERVATION: return "Observation";
7943            case OBSERVATIONDEFINITION: return "ObservationDefinition";
7944            case OPERATIONDEFINITION: return "OperationDefinition";
7945            case OPERATIONOUTCOME: return "OperationOutcome";
7946            case ORGANIZATION: return "Organization";
7947            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
7948            case PARAMETERS: return "Parameters";
7949            case PATIENT: return "Patient";
7950            case PAYMENTNOTICE: return "PaymentNotice";
7951            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
7952            case PERSON: return "Person";
7953            case PLANDEFINITION: return "PlanDefinition";
7954            case PRACTITIONER: return "Practitioner";
7955            case PRACTITIONERROLE: return "PractitionerRole";
7956            case PROCEDURE: return "Procedure";
7957            case PROVENANCE: return "Provenance";
7958            case QUESTIONNAIRE: return "Questionnaire";
7959            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
7960            case RELATEDPERSON: return "RelatedPerson";
7961            case REQUESTGROUP: return "RequestGroup";
7962            case RESEARCHDEFINITION: return "ResearchDefinition";
7963            case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition";
7964            case RESEARCHSTUDY: return "ResearchStudy";
7965            case RESEARCHSUBJECT: return "ResearchSubject";
7966            case RESOURCE: return "Resource";
7967            case RISKASSESSMENT: return "RiskAssessment";
7968            case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis";
7969            case SCHEDULE: return "Schedule";
7970            case SEARCHPARAMETER: return "SearchParameter";
7971            case SERVICEREQUEST: return "ServiceRequest";
7972            case SLOT: return "Slot";
7973            case SPECIMEN: return "Specimen";
7974            case SPECIMENDEFINITION: return "SpecimenDefinition";
7975            case STRUCTUREDEFINITION: return "StructureDefinition";
7976            case STRUCTUREMAP: return "StructureMap";
7977            case SUBSCRIPTION: return "Subscription";
7978            case SUBSTANCE: return "Substance";
7979            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
7980            case SUBSTANCEPOLYMER: return "SubstancePolymer";
7981            case SUBSTANCEPROTEIN: return "SubstanceProtein";
7982            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
7983            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
7984            case SUBSTANCESPECIFICATION: return "SubstanceSpecification";
7985            case SUPPLYDELIVERY: return "SupplyDelivery";
7986            case SUPPLYREQUEST: return "SupplyRequest";
7987            case TASK: return "Task";
7988            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
7989            case TESTREPORT: return "TestReport";
7990            case TESTSCRIPT: return "TestScript";
7991            case VALUESET: return "ValueSet";
7992            case VERIFICATIONRESULT: return "VerificationResult";
7993            case VISIONPRESCRIPTION: return "VisionPrescription";
7994            case NULL: return null;
7995            default: return "?";
7996          }
7997        }
7998        public String getSystem() {
7999          switch (this) {
8000            case ADDRESS: return "http://hl7.org/fhir/data-types";
8001            case AGE: return "http://hl7.org/fhir/data-types";
8002            case ANNOTATION: return "http://hl7.org/fhir/data-types";
8003            case ATTACHMENT: return "http://hl7.org/fhir/data-types";
8004            case BACKBONEELEMENT: return "http://hl7.org/fhir/data-types";
8005            case CODEABLECONCEPT: return "http://hl7.org/fhir/data-types";
8006            case CODING: return "http://hl7.org/fhir/data-types";
8007            case CONTACTDETAIL: return "http://hl7.org/fhir/data-types";
8008            case CONTACTPOINT: return "http://hl7.org/fhir/data-types";
8009            case CONTRIBUTOR: return "http://hl7.org/fhir/data-types";
8010            case COUNT: return "http://hl7.org/fhir/data-types";
8011            case DATAREQUIREMENT: return "http://hl7.org/fhir/data-types";
8012            case DISTANCE: return "http://hl7.org/fhir/data-types";
8013            case DOSAGE: return "http://hl7.org/fhir/data-types";
8014            case DURATION: return "http://hl7.org/fhir/data-types";
8015            case ELEMENT: return "http://hl7.org/fhir/data-types";
8016            case ELEMENTDEFINITION: return "http://hl7.org/fhir/data-types";
8017            case EXPRESSION: return "http://hl7.org/fhir/data-types";
8018            case EXTENSION: return "http://hl7.org/fhir/data-types";
8019            case HUMANNAME: return "http://hl7.org/fhir/data-types";
8020            case IDENTIFIER: return "http://hl7.org/fhir/data-types";
8021            case MARKETINGSTATUS: return "http://hl7.org/fhir/data-types";
8022            case META: return "http://hl7.org/fhir/data-types";
8023            case MONEY: return "http://hl7.org/fhir/data-types";
8024            case MONEYQUANTITY: return "http://hl7.org/fhir/data-types";
8025            case NARRATIVE: return "http://hl7.org/fhir/data-types";
8026            case PARAMETERDEFINITION: return "http://hl7.org/fhir/data-types";
8027            case PERIOD: return "http://hl7.org/fhir/data-types";
8028            case POPULATION: return "http://hl7.org/fhir/data-types";
8029            case PRODCHARACTERISTIC: return "http://hl7.org/fhir/data-types";
8030            case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/data-types";
8031            case QUANTITY: return "http://hl7.org/fhir/data-types";
8032            case RANGE: return "http://hl7.org/fhir/data-types";
8033            case RATIO: return "http://hl7.org/fhir/data-types";
8034            case REFERENCE: return "http://hl7.org/fhir/data-types";
8035            case RELATEDARTIFACT: return "http://hl7.org/fhir/data-types";
8036            case SAMPLEDDATA: return "http://hl7.org/fhir/data-types";
8037            case SIGNATURE: return "http://hl7.org/fhir/data-types";
8038            case SIMPLEQUANTITY: return "http://hl7.org/fhir/data-types";
8039            case SUBSTANCEAMOUNT: return "http://hl7.org/fhir/data-types";
8040            case TIMING: return "http://hl7.org/fhir/data-types";
8041            case TRIGGERDEFINITION: return "http://hl7.org/fhir/data-types";
8042            case USAGECONTEXT: return "http://hl7.org/fhir/data-types";
8043            case BASE64BINARY: return "http://hl7.org/fhir/data-types";
8044            case BOOLEAN: return "http://hl7.org/fhir/data-types";
8045            case CANONICAL: return "http://hl7.org/fhir/data-types";
8046            case CODE: return "http://hl7.org/fhir/data-types";
8047            case DATE: return "http://hl7.org/fhir/data-types";
8048            case DATETIME: return "http://hl7.org/fhir/data-types";
8049            case DECIMAL: return "http://hl7.org/fhir/data-types";
8050            case ID: return "http://hl7.org/fhir/data-types";
8051            case INSTANT: return "http://hl7.org/fhir/data-types";
8052            case INTEGER: return "http://hl7.org/fhir/data-types";
8053            case MARKDOWN: return "http://hl7.org/fhir/data-types";
8054            case OID: return "http://hl7.org/fhir/data-types";
8055            case POSITIVEINT: return "http://hl7.org/fhir/data-types";
8056            case STRING: return "http://hl7.org/fhir/data-types";
8057            case TIME: return "http://hl7.org/fhir/data-types";
8058            case UNSIGNEDINT: return "http://hl7.org/fhir/data-types";
8059            case URI: return "http://hl7.org/fhir/data-types";
8060            case URL: return "http://hl7.org/fhir/data-types";
8061            case UUID: return "http://hl7.org/fhir/data-types";
8062            case XHTML: return "http://hl7.org/fhir/data-types";
8063            case ACCOUNT: return "http://hl7.org/fhir/resource-types";
8064            case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types";
8065            case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types";
8066            case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types";
8067            case APPOINTMENT: return "http://hl7.org/fhir/resource-types";
8068            case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
8069            case AUDITEVENT: return "http://hl7.org/fhir/resource-types";
8070            case BASIC: return "http://hl7.org/fhir/resource-types";
8071            case BINARY: return "http://hl7.org/fhir/resource-types";
8072            case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types";
8073            case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types";
8074            case BUNDLE: return "http://hl7.org/fhir/resource-types";
8075            case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types";
8076            case CAREPLAN: return "http://hl7.org/fhir/resource-types";
8077            case CARETEAM: return "http://hl7.org/fhir/resource-types";
8078            case CATALOGENTRY: return "http://hl7.org/fhir/resource-types";
8079            case CHARGEITEM: return "http://hl7.org/fhir/resource-types";
8080            case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
8081            case CLAIM: return "http://hl7.org/fhir/resource-types";
8082            case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types";
8083            case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types";
8084            case CODESYSTEM: return "http://hl7.org/fhir/resource-types";
8085            case COMMUNICATION: return "http://hl7.org/fhir/resource-types";
8086            case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
8087            case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
8088            case COMPOSITION: return "http://hl7.org/fhir/resource-types";
8089            case CONCEPTMAP: return "http://hl7.org/fhir/resource-types";
8090            case CONDITION: return "http://hl7.org/fhir/resource-types";
8091            case CONSENT: return "http://hl7.org/fhir/resource-types";
8092            case CONTRACT: return "http://hl7.org/fhir/resource-types";
8093            case COVERAGE: return "http://hl7.org/fhir/resource-types";
8094            case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types";
8095            case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types";
8096            case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types";
8097            case DEVICE: return "http://hl7.org/fhir/resource-types";
8098            case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types";
8099            case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types";
8100            case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types";
8101            case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types";
8102            case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types";
8103            case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types";
8104            case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types";
8105            case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types";
8106            case EFFECTEVIDENCESYNTHESIS: return "http://hl7.org/fhir/resource-types";
8107            case ENCOUNTER: return "http://hl7.org/fhir/resource-types";
8108            case ENDPOINT: return "http://hl7.org/fhir/resource-types";
8109            case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types";
8110            case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
8111            case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types";
8112            case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types";
8113            case EVIDENCE: return "http://hl7.org/fhir/resource-types";
8114            case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types";
8115            case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types";
8116            case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types";
8117            case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types";
8118            case FLAG: return "http://hl7.org/fhir/resource-types";
8119            case GOAL: return "http://hl7.org/fhir/resource-types";
8120            case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types";
8121            case GROUP: return "http://hl7.org/fhir/resource-types";
8122            case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types";
8123            case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types";
8124            case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types";
8125            case IMMUNIZATION: return "http://hl7.org/fhir/resource-types";
8126            case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types";
8127            case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types";
8128            case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types";
8129            case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types";
8130            case INVOICE: return "http://hl7.org/fhir/resource-types";
8131            case LIBRARY: return "http://hl7.org/fhir/resource-types";
8132            case LINKAGE: return "http://hl7.org/fhir/resource-types";
8133            case LIST: return "http://hl7.org/fhir/resource-types";
8134            case LOCATION: return "http://hl7.org/fhir/resource-types";
8135            case MEASURE: return "http://hl7.org/fhir/resource-types";
8136            case MEASUREREPORT: return "http://hl7.org/fhir/resource-types";
8137            case MEDIA: return "http://hl7.org/fhir/resource-types";
8138            case MEDICATION: return "http://hl7.org/fhir/resource-types";
8139            case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types";
8140            case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types";
8141            case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types";
8142            case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
8143            case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/resource-types";
8144            case MEDICINALPRODUCT: return "http://hl7.org/fhir/resource-types";
8145            case MEDICINALPRODUCTAUTHORIZATION: return "http://hl7.org/fhir/resource-types";
8146            case MEDICINALPRODUCTCONTRAINDICATION: return "http://hl7.org/fhir/resource-types";
8147            case MEDICINALPRODUCTINDICATION: return "http://hl7.org/fhir/resource-types";
8148            case MEDICINALPRODUCTINGREDIENT: return "http://hl7.org/fhir/resource-types";
8149            case MEDICINALPRODUCTINTERACTION: return "http://hl7.org/fhir/resource-types";
8150            case MEDICINALPRODUCTMANUFACTURED: return "http://hl7.org/fhir/resource-types";
8151            case MEDICINALPRODUCTPACKAGED: return "http://hl7.org/fhir/resource-types";
8152            case MEDICINALPRODUCTPHARMACEUTICAL: return "http://hl7.org/fhir/resource-types";
8153            case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "http://hl7.org/fhir/resource-types";
8154            case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types";
8155            case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types";
8156            case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types";
8157            case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types";
8158            case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types";
8159            case OBSERVATION: return "http://hl7.org/fhir/resource-types";
8160            case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
8161            case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
8162            case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types";
8163            case ORGANIZATION: return "http://hl7.org/fhir/resource-types";
8164            case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types";
8165            case PARAMETERS: return "http://hl7.org/fhir/resource-types";
8166            case PATIENT: return "http://hl7.org/fhir/resource-types";
8167            case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types";
8168            case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types";
8169            case PERSON: return "http://hl7.org/fhir/resource-types";
8170            case PLANDEFINITION: return "http://hl7.org/fhir/resource-types";
8171            case PRACTITIONER: return "http://hl7.org/fhir/resource-types";
8172            case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types";
8173            case PROCEDURE: return "http://hl7.org/fhir/resource-types";
8174            case PROVENANCE: return "http://hl7.org/fhir/resource-types";
8175            case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types";
8176            case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types";
8177            case RELATEDPERSON: return "http://hl7.org/fhir/resource-types";
8178            case REQUESTGROUP: return "http://hl7.org/fhir/resource-types";
8179            case RESEARCHDEFINITION: return "http://hl7.org/fhir/resource-types";
8180            case RESEARCHELEMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
8181            case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types";
8182            case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types";
8183            case RESOURCE: return "http://hl7.org/fhir/resource-types";
8184            case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types";
8185            case RISKEVIDENCESYNTHESIS: return "http://hl7.org/fhir/resource-types";
8186            case SCHEDULE: return "http://hl7.org/fhir/resource-types";
8187            case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types";
8188            case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types";
8189            case SLOT: return "http://hl7.org/fhir/resource-types";
8190            case SPECIMEN: return "http://hl7.org/fhir/resource-types";
8191            case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types";
8192            case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types";
8193            case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types";
8194            case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types";
8195            case SUBSTANCE: return "http://hl7.org/fhir/resource-types";
8196            case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types";
8197            case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types";
8198            case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types";
8199            case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types";
8200            case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types";
8201            case SUBSTANCESPECIFICATION: return "http://hl7.org/fhir/resource-types";
8202            case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types";
8203            case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types";
8204            case TASK: return "http://hl7.org/fhir/resource-types";
8205            case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types";
8206            case TESTREPORT: return "http://hl7.org/fhir/resource-types";
8207            case TESTSCRIPT: return "http://hl7.org/fhir/resource-types";
8208            case VALUESET: return "http://hl7.org/fhir/resource-types";
8209            case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types";
8210            case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types";
8211            case NULL: return null;
8212            default: return "?";
8213          }
8214        }
8215        public String getDefinition() {
8216          switch (this) {
8217            case ADDRESS: return "An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world.";
8218            case AGE: return "A duration of time during which an organism (or a process) has existed.";
8219            case ANNOTATION: return "A  text note which also  contains information about who made the statement and when.";
8220            case ATTACHMENT: return "For referring to data content defined in other formats.";
8221            case BACKBONEELEMENT: return "Base definition for all elements that are defined inside a resource - but not those in a data type.";
8222            case CODEABLECONCEPT: return "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.";
8223            case CODING: return "A reference to a code defined by a terminology system.";
8224            case CONTACTDETAIL: return "Specifies contact information for a person or organization.";
8225            case CONTACTPOINT: return "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.";
8226            case CONTRIBUTOR: return "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.";
8227            case COUNT: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
8228            case DATAREQUIREMENT: return "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.";
8229            case DISTANCE: return "A length - a value with a unit that is a physical distance.";
8230            case DOSAGE: return "Indicates how the medication is/was taken or should be taken by the patient.";
8231            case DURATION: return "A length of time.";
8232            case ELEMENT: return "Base definition for all elements in a resource.";
8233            case ELEMENTDEFINITION: return "Captures constraints on each element within the resource, profile, or extension.";
8234            case EXPRESSION: return "A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.";
8235            case EXTENSION: return "Optional Extension Element - found in all resources.";
8236            case HUMANNAME: return "A human's name with the ability to identify parts and usage.";
8237            case IDENTIFIER: return "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.";
8238            case MARKETINGSTATUS: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
8239            case META: return "The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.";
8240            case MONEY: return "An amount of economic utility in some recognized currency.";
8241            case MONEYQUANTITY: return "";
8242            case NARRATIVE: return "A human-readable summary of the resource conveying the essential clinical and business information for the resource.";
8243            case PARAMETERDEFINITION: return "The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.";
8244            case PERIOD: return "A time period defined by a start and end date and optionally time.";
8245            case POPULATION: return "A populatioof people with some set of grouping criteria.";
8246            case PRODCHARACTERISTIC: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.";
8247            case PRODUCTSHELFLIFE: return "The shelf-life and storage information for a medicinal product item or container can be described using this class.";
8248            case QUANTITY: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.";
8249            case RANGE: return "A set of ordered Quantities defined by a low and high limit.";
8250            case RATIO: return "A relationship of two Quantity values - expressed as a numerator and a denominator.";
8251            case REFERENCE: return "A reference from one resource to another.";
8252            case RELATEDARTIFACT: return "Related artifacts such as additional documentation, justification, or bibliographic references.";
8253            case SAMPLEDDATA: return "A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.";
8254            case SIGNATURE: return "A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.";
8255            case SIMPLEQUANTITY: return "";
8256            case SUBSTANCEAMOUNT: return "Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.";
8257            case TIMING: return "Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.";
8258            case TRIGGERDEFINITION: return "A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.";
8259            case USAGECONTEXT: return "Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).";
8260            case BASE64BINARY: return "A stream of bytes";
8261            case BOOLEAN: return "Value of \"true\" or \"false\"";
8262            case CANONICAL: return "A URI that is a reference to a canonical URL on a FHIR resource";
8263            case CODE: return "A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents";
8264            case DATE: return "A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.";
8265            case DATETIME: return "A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.";
8266            case DECIMAL: return "A rational number with implicit precision";
8267            case ID: return "Any combination of letters, numerals, \"-\" and \".\", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.";
8268            case INSTANT: return "An instant in time - known at least to the second";
8269            case INTEGER: return "A whole number";
8270            case MARKDOWN: return "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine";
8271            case OID: return "An OID represented as a URI";
8272            case POSITIVEINT: return "An integer with a value that is positive (e.g. >0)";
8273            case STRING: return "A sequence of Unicode characters";
8274            case TIME: return "A time during the day, with no date specified";
8275            case UNSIGNEDINT: return "An integer with a value that is not negative (e.g. >= 0)";
8276            case URI: return "String of characters used to identify a name or a resource";
8277            case URL: return "A URI that is a literal reference";
8278            case UUID: return "A UUID, represented as a URI";
8279            case XHTML: return "XHTML format, as defined by W3C, but restricted usage (mainly, no active content)";
8280            case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose.  In the healthcare field, used to track charges for a patient, cost centers, etc.";
8281            case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.";
8282            case ADVERSEEVENT: return "Actual or  potential/avoided event causing unintended physical injury resulting from or contributed to by medical care, a research study or other healthcare setting factors that requires additional monitoring, treatment, or hospitalization, or that results in death.";
8283            case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.";
8284            case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s).";
8285            case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.";
8286            case AUDITEVENT: return "A record of an event made for purposes of maintaining a security log. Typical uses include detection of intrusion attempts and monitoring for inappropriate usage.";
8287            case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification.";
8288            case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format.  A Binary resource can contain any content, whether text, image, pdf, zip archive, etc.";
8289            case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity.";
8290            case BODYSTRUCTURE: return "Record details about an anatomical structure.  This resource may be used when a coded concept does not provide the necessary detail needed for the use case.";
8291            case BUNDLE: return "A container for a collection of resources.";
8292            case CAPABILITYSTATEMENT: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation.";
8293            case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions.";
8294            case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care for a patient.";
8295            case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog.";
8296            case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation.";
8297            case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system.";
8298            case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement.";
8299            case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource.";
8300            case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter,  but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score.";
8301            case CODESYSTEM: return "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.";
8302            case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition.";
8303            case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition.";
8304            case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server.";
8305            case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.).";
8306            case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models.";
8307            case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.";
8308            case CONSENT: return "A record of a healthcare consumer?s  choices, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time.";
8309            case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.";
8310            case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.";
8311            case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy.";
8312            case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.";
8313            case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc.";
8314            case DEVICE: return "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.";
8315            case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device.";
8316            case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device.";
8317            case DEVICEREQUEST: return "Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker.";
8318            case DEVICEUSESTATEMENT: return "A record of a device being used by a patient where the record is the result of a report from the patient or another clinician.";
8319            case DIAGNOSTICREPORT: return "The findings and interpretation of diagnostic  tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports.";
8320            case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection.";
8321            case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. Provides metadata about the document so that the document can be discovered and managed. The scope of a document is any seralized object with a mime-type, so includes formal patient centric documents (CDA), cliical notes, scanned paper, and non-patient specific documents like policy text.";
8322            case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources.";
8323            case EFFECTEVIDENCESYNTHESIS: return "The EffectEvidenceSynthesis resource describes the difference in an outcome between exposures states in a population where the effect estimate is derived from a combination of research studies.";
8324            case ENCOUNTER: return "An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient.";
8325            case ENDPOINT: return "The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information.";
8326            case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage.";
8327            case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.";
8328            case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time.";
8329            case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur.";
8330            case EVIDENCE: return "The Evidence resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about.";
8331            case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about.";
8332            case EXAMPLESCENARIO: return "Example of workflow instance.";
8333            case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided.";
8334            case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient.";
8335            case FLAG: return "Prospective warnings of potential issues when providing care to the patient.";
8336            case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.";
8337            case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set.";
8338            case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization.";
8339            case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken.";
8340            case HEALTHCARESERVICE: return "The details of a healthcare service available at a location.";
8341            case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context.  A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities.";
8342            case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party.";
8343            case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those  recommendations.";
8344            case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.";
8345            case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts.";
8346            case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization.";
8347            case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.";
8348            case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets.";
8349            case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\".";
8350            case LIST: return "A list is a curated collection of resources.";
8351            case LOCATION: return "Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.";
8352            case MEASURE: return "The Measure resource provides the definition of a quality measure.";
8353            case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.";
8354            case MEDIA: return "A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.";
8355            case MEDICATION: return "This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use.";