001package org.hl7.fhir.r5.model;
002
003
004/*
005 * #%L
006 * org.hl7.fhir.r5
007 * %%
008 * Copyright (C) 2014 - 2019 Health Level 7
009 * %%
010 * Licensed under the Apache License, Version 2.0 (the \"License\");
011 * you may not use this file except in compliance with the License.
012 * You may obtain a copy of the License at
013 * 
014 *      http://www.apache.org/licenses/LICENSE-2.0
015 * 
016 * Unless required by applicable law or agreed to in writing, software
017 * distributed under the License is distributed on an \"AS IS\" BASIS,
018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
019 * See the License for the specific language governing permissions and
020 * limitations under the License.
021 * #L%
022 */
023
024/*
025  Copyright (c) 2011+, HL7, Inc.
026  All rights reserved.
027  
028  Redistribution and use in source and binary forms, with or without modification, \
029  are permitted provided that the following conditions are met:
030  
031   * Redistributions of source code must retain the above copyright notice, this \
032     list of conditions and the following disclaimer.
033   * Redistributions in binary form must reproduce the above copyright notice, \
034     this list of conditions and the following disclaimer in the documentation \
035     and/or other materials provided with the distribution.
036   * Neither the name of HL7 nor the names of its contributors may be used to 
037     endorse or promote products derived from this software without specific 
038     prior written permission.
039  
040  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
041  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
042  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
043  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
044  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
045  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
046  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
047  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
048  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
049  POSSIBILITY OF SUCH DAMAGE.
050  */
051
052// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent
053
054
055import org.hl7.fhir.instance.model.api.*;
056import org.hl7.fhir.exceptions.FHIRException;
057
058public class Enumerations {
059
060// In here: 
061//   ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestGroup]
062//   ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestGroup]
063//   ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestGroup]
064//   ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition]
065//   ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestGroup]
066//   ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestGroup]
067//   ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestGroup]
068//   ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestGroup]
069//   AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson]
070//   BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition]
071//   CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, CapabilityStatement2, TerminologyCapabilities]
072//   ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, CoverageEligibilityResponse, EnrollmentResponse, ExplanationOfBenefit, PaymentReconciliation]
073//   CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition]
074//   CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference]
075//   ConceptMapRelationship: The relationship between concepts.[ConceptMap]
076//   DaysOfWeek: The days of the week.[HealthcareService, Location, PractitionerRole, Timing]
077//   DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition]
078//   DocumentReferenceStatus: The status of the document reference.[DocumentManifest, DocumentReference]
079//   DocumentRelationshipType: The type of relationship between documents.[Composition, DocumentReference]
080//   EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, Procedure]
081//   FHIRAllTypes: A list of all the concrete types defined in this version of the FHIR specification - Abstract Types, Data Types and Resource Types.[DataRequirement, OperationDefinition, ParameterDefinition]
082//   FHIRVersion: All published FHIR Versions.[CapabilityStatement, CapabilityStatement2, ImplementationGuide, StructureDefinition]
083//   FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet]
084//   FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription]
085//   InvoicePriceComponentType: Codes indicating the kind of the price component.[ChargeItemDefinition, Invoice]
086//   ListMode: The processing mode that applies to this list.[Composition, List]
087//   MeasureImprovementNotation: Observation values that indicate what change in a measurement value or score is indicative of an improvement in the measured item or scored issue.[Measure, MeasureReport]
088//   MimeTypes: This value set includes all possible codes from BCP-13 (http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, CapabilityStatement2, ElementDefinition, Endpoint, Signature, Subscription, TestScript]
089//   NoteType: The presentation types of notes.[ClaimResponse, ExplanationOfBenefit, PaymentReconciliation]
090//   ObservationStatus: Codes providing the status of an observation.[DetectedIssue, Observation, RiskAssessment]
091//   OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition]
092//   ParticipationStatus: The Participation status of an appointment.[Appointment, AppointmentResponse]
093//   PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, CanonicalResource, CapabilityStatement, CapabilityStatement2, ChargeItemDefinition, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, InsurancePlan, Library, Measure, MessageDefinition, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, TerminologyCapabilities, TestScript, Topic, ValueSet]
094//   QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity]
095//   RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, DeviceRequest, NutritionOrder, RequestGroup, ServiceRequest]
096//   RequestPriority: The clinical priority of a diagnostic order.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, PlanDefinition, RequestGroup, ServiceRequest, SupplyRequest, Task]
097//   RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestGroup, ServiceRequest]
098//   ResourceTypeEnum: One of the resource types defined as part of this version of FHIR.[CapabilityStatement, CapabilityStatement2, CompartmentDefinition, ExampleScenario, GraphDefinition, ImplementationGuide, MessageDefinition, OperationDefinition, Questionnaire, SearchParameter, Topic]
099//   RestfulCapabilityMode: The mode of a RESTful capability statement.[CapabilityStatement, CapabilityStatement2]
100//   SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, CapabilityStatement2, OperationDefinition, SearchParameter]
101//   Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit]
102
103
104    public enum ActionCardinalityBehavior {
105        /**
106         * The action may only be selected one time.
107         */
108        SINGLE, 
109        /**
110         * The action may be selected multiple times.
111         */
112        MULTIPLE, 
113        /**
114         * added to help the parsers
115         */
116        NULL;
117        public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException {
118            if (codeString == null || "".equals(codeString))
119                return null;
120        if ("single".equals(codeString))
121          return SINGLE;
122        if ("multiple".equals(codeString))
123          return MULTIPLE;
124        throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
125        }
126        public String toCode() {
127          switch (this) {
128            case SINGLE: return "single";
129            case MULTIPLE: return "multiple";
130            default: return "?";
131          }
132        }
133        public String getSystem() {
134          switch (this) {
135            case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior";
136            case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior";
137            default: return "?";
138          }
139        }
140        public String getDefinition() {
141          switch (this) {
142            case SINGLE: return "The action may only be selected one time.";
143            case MULTIPLE: return "The action may be selected multiple times.";
144            default: return "?";
145          }
146        }
147        public String getDisplay() {
148          switch (this) {
149            case SINGLE: return "Single";
150            case MULTIPLE: return "Multiple";
151            default: return "?";
152          }
153        }
154    }
155
156  public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> {
157    public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException {
158      if (codeString == null || "".equals(codeString))
159            if (codeString == null || "".equals(codeString))
160                return null;
161        if ("single".equals(codeString))
162          return ActionCardinalityBehavior.SINGLE;
163        if ("multiple".equals(codeString))
164          return ActionCardinalityBehavior.MULTIPLE;
165        throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
166        }
167        public Enumeration<ActionCardinalityBehavior> fromType(Base code) throws FHIRException {
168          if (code == null)
169            return null;
170          if (code.isEmpty())
171            return new Enumeration<ActionCardinalityBehavior>(this);
172          String codeString = ((PrimitiveType) code).asStringValue();
173          if (codeString == null || "".equals(codeString))
174            return null;
175        if ("single".equals(codeString))
176          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE);
177        if ("multiple".equals(codeString))
178          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE);
179        throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
180        }
181    public String toCode(ActionCardinalityBehavior code) {
182      if (code == ActionCardinalityBehavior.SINGLE)
183        return "single";
184      if (code == ActionCardinalityBehavior.MULTIPLE)
185        return "multiple";
186      return "?";
187      }
188    public String toSystem(ActionCardinalityBehavior code) {
189      return code.getSystem();
190      }
191    }
192
193    public enum ActionConditionKind {
194        /**
195         * The condition describes whether or not a given action is applicable.
196         */
197        APPLICABILITY, 
198        /**
199         * The condition is a starting condition for the action.
200         */
201        START, 
202        /**
203         * The condition is a stop, or exit condition for the action.
204         */
205        STOP, 
206        /**
207         * added to help the parsers
208         */
209        NULL;
210        public static ActionConditionKind fromCode(String codeString) throws FHIRException {
211            if (codeString == null || "".equals(codeString))
212                return null;
213        if ("applicability".equals(codeString))
214          return APPLICABILITY;
215        if ("start".equals(codeString))
216          return START;
217        if ("stop".equals(codeString))
218          return STOP;
219        throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
220        }
221        public String toCode() {
222          switch (this) {
223            case APPLICABILITY: return "applicability";
224            case START: return "start";
225            case STOP: return "stop";
226            default: return "?";
227          }
228        }
229        public String getSystem() {
230          switch (this) {
231            case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind";
232            case START: return "http://hl7.org/fhir/action-condition-kind";
233            case STOP: return "http://hl7.org/fhir/action-condition-kind";
234            default: return "?";
235          }
236        }
237        public String getDefinition() {
238          switch (this) {
239            case APPLICABILITY: return "The condition describes whether or not a given action is applicable.";
240            case START: return "The condition is a starting condition for the action.";
241            case STOP: return "The condition is a stop, or exit condition for the action.";
242            default: return "?";
243          }
244        }
245        public String getDisplay() {
246          switch (this) {
247            case APPLICABILITY: return "Applicability";
248            case START: return "Start";
249            case STOP: return "Stop";
250            default: return "?";
251          }
252        }
253    }
254
255  public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> {
256    public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException {
257      if (codeString == null || "".equals(codeString))
258            if (codeString == null || "".equals(codeString))
259                return null;
260        if ("applicability".equals(codeString))
261          return ActionConditionKind.APPLICABILITY;
262        if ("start".equals(codeString))
263          return ActionConditionKind.START;
264        if ("stop".equals(codeString))
265          return ActionConditionKind.STOP;
266        throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'");
267        }
268        public Enumeration<ActionConditionKind> fromType(Base code) throws FHIRException {
269          if (code == null)
270            return null;
271          if (code.isEmpty())
272            return new Enumeration<ActionConditionKind>(this);
273          String codeString = ((PrimitiveType) code).asStringValue();
274          if (codeString == null || "".equals(codeString))
275            return null;
276        if ("applicability".equals(codeString))
277          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY);
278        if ("start".equals(codeString))
279          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START);
280        if ("stop".equals(codeString))
281          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP);
282        throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
283        }
284    public String toCode(ActionConditionKind code) {
285      if (code == ActionConditionKind.APPLICABILITY)
286        return "applicability";
287      if (code == ActionConditionKind.START)
288        return "start";
289      if (code == ActionConditionKind.STOP)
290        return "stop";
291      return "?";
292      }
293    public String toSystem(ActionConditionKind code) {
294      return code.getSystem();
295      }
296    }
297
298    public enum ActionGroupingBehavior {
299        /**
300         * Any group marked with this behavior should be displayed as a visual group to the end user.
301         */
302        VISUALGROUP, 
303        /**
304         * A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so.
305         */
306        LOGICALGROUP, 
307        /**
308         * A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne".
309         */
310        SENTENCEGROUP, 
311        /**
312         * added to help the parsers
313         */
314        NULL;
315        public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException {
316            if (codeString == null || "".equals(codeString))
317                return null;
318        if ("visual-group".equals(codeString))
319          return VISUALGROUP;
320        if ("logical-group".equals(codeString))
321          return LOGICALGROUP;
322        if ("sentence-group".equals(codeString))
323          return SENTENCEGROUP;
324        throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
325        }
326        public String toCode() {
327          switch (this) {
328            case VISUALGROUP: return "visual-group";
329            case LOGICALGROUP: return "logical-group";
330            case SENTENCEGROUP: return "sentence-group";
331            default: return "?";
332          }
333        }
334        public String getSystem() {
335          switch (this) {
336            case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
337            case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
338            case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
339            default: return "?";
340          }
341        }
342        public String getDefinition() {
343          switch (this) {
344            case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user.";
345            case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so.";
346            case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\".";
347            default: return "?";
348          }
349        }
350        public String getDisplay() {
351          switch (this) {
352            case VISUALGROUP: return "Visual Group";
353            case LOGICALGROUP: return "Logical Group";
354            case SENTENCEGROUP: return "Sentence Group";
355            default: return "?";
356          }
357        }
358    }
359
360  public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> {
361    public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException {
362      if (codeString == null || "".equals(codeString))
363            if (codeString == null || "".equals(codeString))
364                return null;
365        if ("visual-group".equals(codeString))
366          return ActionGroupingBehavior.VISUALGROUP;
367        if ("logical-group".equals(codeString))
368          return ActionGroupingBehavior.LOGICALGROUP;
369        if ("sentence-group".equals(codeString))
370          return ActionGroupingBehavior.SENTENCEGROUP;
371        throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'");
372        }
373        public Enumeration<ActionGroupingBehavior> fromType(Base code) throws FHIRException {
374          if (code == null)
375            return null;
376          if (code.isEmpty())
377            return new Enumeration<ActionGroupingBehavior>(this);
378          String codeString = ((PrimitiveType) code).asStringValue();
379          if (codeString == null || "".equals(codeString))
380            return null;
381        if ("visual-group".equals(codeString))
382          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP);
383        if ("logical-group".equals(codeString))
384          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP);
385        if ("sentence-group".equals(codeString))
386          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP);
387        throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
388        }
389    public String toCode(ActionGroupingBehavior code) {
390      if (code == ActionGroupingBehavior.VISUALGROUP)
391        return "visual-group";
392      if (code == ActionGroupingBehavior.LOGICALGROUP)
393        return "logical-group";
394      if (code == ActionGroupingBehavior.SENTENCEGROUP)
395        return "sentence-group";
396      return "?";
397      }
398    public String toSystem(ActionGroupingBehavior code) {
399      return code.getSystem();
400      }
401    }
402
403    public enum ActionParticipantType {
404        /**
405         * The participant is the patient under evaluation.
406         */
407        PATIENT, 
408        /**
409         * The participant is a practitioner involved in the patient's care.
410         */
411        PRACTITIONER, 
412        /**
413         * The participant is a person related to the patient.
414         */
415        RELATEDPERSON, 
416        /**
417         * The participant is a system or device used in the care of the patient.
418         */
419        DEVICE, 
420        /**
421         * added to help the parsers
422         */
423        NULL;
424        public static ActionParticipantType fromCode(String codeString) throws FHIRException {
425            if (codeString == null || "".equals(codeString))
426                return null;
427        if ("patient".equals(codeString))
428          return PATIENT;
429        if ("practitioner".equals(codeString))
430          return PRACTITIONER;
431        if ("related-person".equals(codeString))
432          return RELATEDPERSON;
433        if ("device".equals(codeString))
434          return DEVICE;
435        throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
436        }
437        public String toCode() {
438          switch (this) {
439            case PATIENT: return "patient";
440            case PRACTITIONER: return "practitioner";
441            case RELATEDPERSON: return "related-person";
442            case DEVICE: return "device";
443            default: return "?";
444          }
445        }
446        public String getSystem() {
447          switch (this) {
448            case PATIENT: return "http://hl7.org/fhir/action-participant-type";
449            case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type";
450            case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type";
451            case DEVICE: return "http://hl7.org/fhir/action-participant-type";
452            default: return "?";
453          }
454        }
455        public String getDefinition() {
456          switch (this) {
457            case PATIENT: return "The participant is the patient under evaluation.";
458            case PRACTITIONER: return "The participant is a practitioner involved in the patient's care.";
459            case RELATEDPERSON: return "The participant is a person related to the patient.";
460            case DEVICE: return "The participant is a system or device used in the care of the patient.";
461            default: return "?";
462          }
463        }
464        public String getDisplay() {
465          switch (this) {
466            case PATIENT: return "Patient";
467            case PRACTITIONER: return "Practitioner";
468            case RELATEDPERSON: return "Related Person";
469            case DEVICE: return "Device";
470            default: return "?";
471          }
472        }
473    }
474
475  public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> {
476    public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException {
477      if (codeString == null || "".equals(codeString))
478            if (codeString == null || "".equals(codeString))
479                return null;
480        if ("patient".equals(codeString))
481          return ActionParticipantType.PATIENT;
482        if ("practitioner".equals(codeString))
483          return ActionParticipantType.PRACTITIONER;
484        if ("related-person".equals(codeString))
485          return ActionParticipantType.RELATEDPERSON;
486        if ("device".equals(codeString))
487          return ActionParticipantType.DEVICE;
488        throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'");
489        }
490        public Enumeration<ActionParticipantType> fromType(Base code) throws FHIRException {
491          if (code == null)
492            return null;
493          if (code.isEmpty())
494            return new Enumeration<ActionParticipantType>(this);
495          String codeString = ((PrimitiveType) code).asStringValue();
496          if (codeString == null || "".equals(codeString))
497            return null;
498        if ("patient".equals(codeString))
499          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT);
500        if ("practitioner".equals(codeString))
501          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER);
502        if ("related-person".equals(codeString))
503          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON);
504        if ("device".equals(codeString))
505          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE);
506        throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
507        }
508    public String toCode(ActionParticipantType code) {
509      if (code == ActionParticipantType.PATIENT)
510        return "patient";
511      if (code == ActionParticipantType.PRACTITIONER)
512        return "practitioner";
513      if (code == ActionParticipantType.RELATEDPERSON)
514        return "related-person";
515      if (code == ActionParticipantType.DEVICE)
516        return "device";
517      return "?";
518      }
519    public String toSystem(ActionParticipantType code) {
520      return code.getSystem();
521      }
522    }
523
524    public enum ActionPrecheckBehavior {
525        /**
526         * An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user.
527         */
528        YES, 
529        /**
530         * An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action.
531         */
532        NO, 
533        /**
534         * added to help the parsers
535         */
536        NULL;
537        public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException {
538            if (codeString == null || "".equals(codeString))
539                return null;
540        if ("yes".equals(codeString))
541          return YES;
542        if ("no".equals(codeString))
543          return NO;
544        throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
545        }
546        public String toCode() {
547          switch (this) {
548            case YES: return "yes";
549            case NO: return "no";
550            default: return "?";
551          }
552        }
553        public String getSystem() {
554          switch (this) {
555            case YES: return "http://hl7.org/fhir/action-precheck-behavior";
556            case NO: return "http://hl7.org/fhir/action-precheck-behavior";
557            default: return "?";
558          }
559        }
560        public String getDefinition() {
561          switch (this) {
562            case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user.";
563            case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action.";
564            default: return "?";
565          }
566        }
567        public String getDisplay() {
568          switch (this) {
569            case YES: return "Yes";
570            case NO: return "No";
571            default: return "?";
572          }
573        }
574    }
575
576  public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> {
577    public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException {
578      if (codeString == null || "".equals(codeString))
579            if (codeString == null || "".equals(codeString))
580                return null;
581        if ("yes".equals(codeString))
582          return ActionPrecheckBehavior.YES;
583        if ("no".equals(codeString))
584          return ActionPrecheckBehavior.NO;
585        throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
586        }
587        public Enumeration<ActionPrecheckBehavior> fromType(Base code) throws FHIRException {
588          if (code == null)
589            return null;
590          if (code.isEmpty())
591            return new Enumeration<ActionPrecheckBehavior>(this);
592          String codeString = ((PrimitiveType) code).asStringValue();
593          if (codeString == null || "".equals(codeString))
594            return null;
595        if ("yes".equals(codeString))
596          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES);
597        if ("no".equals(codeString))
598          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO);
599        throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
600        }
601    public String toCode(ActionPrecheckBehavior code) {
602      if (code == ActionPrecheckBehavior.YES)
603        return "yes";
604      if (code == ActionPrecheckBehavior.NO)
605        return "no";
606      return "?";
607      }
608    public String toSystem(ActionPrecheckBehavior code) {
609      return code.getSystem();
610      }
611    }
612
613    public enum ActionRelationshipType {
614        /**
615         * The action must be performed before the start of the related action.
616         */
617        BEFORESTART, 
618        /**
619         * The action must be performed before the related action.
620         */
621        BEFORE, 
622        /**
623         * The action must be performed before the end of the related action.
624         */
625        BEFOREEND, 
626        /**
627         * The action must be performed concurrent with the start of the related action.
628         */
629        CONCURRENTWITHSTART, 
630        /**
631         * The action must be performed concurrent with the related action.
632         */
633        CONCURRENT, 
634        /**
635         * The action must be performed concurrent with the end of the related action.
636         */
637        CONCURRENTWITHEND, 
638        /**
639         * The action must be performed after the start of the related action.
640         */
641        AFTERSTART, 
642        /**
643         * The action must be performed after the related action.
644         */
645        AFTER, 
646        /**
647         * The action must be performed after the end of the related action.
648         */
649        AFTEREND, 
650        /**
651         * added to help the parsers
652         */
653        NULL;
654        public static ActionRelationshipType fromCode(String codeString) throws FHIRException {
655            if (codeString == null || "".equals(codeString))
656                return null;
657        if ("before-start".equals(codeString))
658          return BEFORESTART;
659        if ("before".equals(codeString))
660          return BEFORE;
661        if ("before-end".equals(codeString))
662          return BEFOREEND;
663        if ("concurrent-with-start".equals(codeString))
664          return CONCURRENTWITHSTART;
665        if ("concurrent".equals(codeString))
666          return CONCURRENT;
667        if ("concurrent-with-end".equals(codeString))
668          return CONCURRENTWITHEND;
669        if ("after-start".equals(codeString))
670          return AFTERSTART;
671        if ("after".equals(codeString))
672          return AFTER;
673        if ("after-end".equals(codeString))
674          return AFTEREND;
675        throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
676        }
677        public String toCode() {
678          switch (this) {
679            case BEFORESTART: return "before-start";
680            case BEFORE: return "before";
681            case BEFOREEND: return "before-end";
682            case CONCURRENTWITHSTART: return "concurrent-with-start";
683            case CONCURRENT: return "concurrent";
684            case CONCURRENTWITHEND: return "concurrent-with-end";
685            case AFTERSTART: return "after-start";
686            case AFTER: return "after";
687            case AFTEREND: return "after-end";
688            default: return "?";
689          }
690        }
691        public String getSystem() {
692          switch (this) {
693            case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type";
694            case BEFORE: return "http://hl7.org/fhir/action-relationship-type";
695            case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type";
696            case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type";
697            case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type";
698            case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type";
699            case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type";
700            case AFTER: return "http://hl7.org/fhir/action-relationship-type";
701            case AFTEREND: return "http://hl7.org/fhir/action-relationship-type";
702            default: return "?";
703          }
704        }
705        public String getDefinition() {
706          switch (this) {
707            case BEFORESTART: return "The action must be performed before the start of the related action.";
708            case BEFORE: return "The action must be performed before the related action.";
709            case BEFOREEND: return "The action must be performed before the end of the related action.";
710            case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action.";
711            case CONCURRENT: return "The action must be performed concurrent with the related action.";
712            case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action.";
713            case AFTERSTART: return "The action must be performed after the start of the related action.";
714            case AFTER: return "The action must be performed after the related action.";
715            case AFTEREND: return "The action must be performed after the end of the related action.";
716            default: return "?";
717          }
718        }
719        public String getDisplay() {
720          switch (this) {
721            case BEFORESTART: return "Before Start";
722            case BEFORE: return "Before";
723            case BEFOREEND: return "Before End";
724            case CONCURRENTWITHSTART: return "Concurrent With Start";
725            case CONCURRENT: return "Concurrent";
726            case CONCURRENTWITHEND: return "Concurrent With End";
727            case AFTERSTART: return "After Start";
728            case AFTER: return "After";
729            case AFTEREND: return "After End";
730            default: return "?";
731          }
732        }
733    }
734
735  public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> {
736    public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException {
737      if (codeString == null || "".equals(codeString))
738            if (codeString == null || "".equals(codeString))
739                return null;
740        if ("before-start".equals(codeString))
741          return ActionRelationshipType.BEFORESTART;
742        if ("before".equals(codeString))
743          return ActionRelationshipType.BEFORE;
744        if ("before-end".equals(codeString))
745          return ActionRelationshipType.BEFOREEND;
746        if ("concurrent-with-start".equals(codeString))
747          return ActionRelationshipType.CONCURRENTWITHSTART;
748        if ("concurrent".equals(codeString))
749          return ActionRelationshipType.CONCURRENT;
750        if ("concurrent-with-end".equals(codeString))
751          return ActionRelationshipType.CONCURRENTWITHEND;
752        if ("after-start".equals(codeString))
753          return ActionRelationshipType.AFTERSTART;
754        if ("after".equals(codeString))
755          return ActionRelationshipType.AFTER;
756        if ("after-end".equals(codeString))
757          return ActionRelationshipType.AFTEREND;
758        throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'");
759        }
760        public Enumeration<ActionRelationshipType> fromType(Base code) throws FHIRException {
761          if (code == null)
762            return null;
763          if (code.isEmpty())
764            return new Enumeration<ActionRelationshipType>(this);
765          String codeString = ((PrimitiveType) code).asStringValue();
766          if (codeString == null || "".equals(codeString))
767            return null;
768        if ("before-start".equals(codeString))
769          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART);
770        if ("before".equals(codeString))
771          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE);
772        if ("before-end".equals(codeString))
773          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND);
774        if ("concurrent-with-start".equals(codeString))
775          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART);
776        if ("concurrent".equals(codeString))
777          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT);
778        if ("concurrent-with-end".equals(codeString))
779          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND);
780        if ("after-start".equals(codeString))
781          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART);
782        if ("after".equals(codeString))
783          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER);
784        if ("after-end".equals(codeString))
785          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND);
786        throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
787        }
788    public String toCode(ActionRelationshipType code) {
789      if (code == ActionRelationshipType.BEFORESTART)
790        return "before-start";
791      if (code == ActionRelationshipType.BEFORE)
792        return "before";
793      if (code == ActionRelationshipType.BEFOREEND)
794        return "before-end";
795      if (code == ActionRelationshipType.CONCURRENTWITHSTART)
796        return "concurrent-with-start";
797      if (code == ActionRelationshipType.CONCURRENT)
798        return "concurrent";
799      if (code == ActionRelationshipType.CONCURRENTWITHEND)
800        return "concurrent-with-end";
801      if (code == ActionRelationshipType.AFTERSTART)
802        return "after-start";
803      if (code == ActionRelationshipType.AFTER)
804        return "after";
805      if (code == ActionRelationshipType.AFTEREND)
806        return "after-end";
807      return "?";
808      }
809    public String toSystem(ActionRelationshipType code) {
810      return code.getSystem();
811      }
812    }
813
814    public enum ActionRequiredBehavior {
815        /**
816         * An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action.
817         */
818        MUST, 
819        /**
820         * An action with this behavior may be included in the set of actions processed by the end user.
821         */
822        COULD, 
823        /**
824         * An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included.
825         */
826        MUSTUNLESSDOCUMENTED, 
827        /**
828         * added to help the parsers
829         */
830        NULL;
831        public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException {
832            if (codeString == null || "".equals(codeString))
833                return null;
834        if ("must".equals(codeString))
835          return MUST;
836        if ("could".equals(codeString))
837          return COULD;
838        if ("must-unless-documented".equals(codeString))
839          return MUSTUNLESSDOCUMENTED;
840        throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
841        }
842        public String toCode() {
843          switch (this) {
844            case MUST: return "must";
845            case COULD: return "could";
846            case MUSTUNLESSDOCUMENTED: return "must-unless-documented";
847            default: return "?";
848          }
849        }
850        public String getSystem() {
851          switch (this) {
852            case MUST: return "http://hl7.org/fhir/action-required-behavior";
853            case COULD: return "http://hl7.org/fhir/action-required-behavior";
854            case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior";
855            default: return "?";
856          }
857        }
858        public String getDefinition() {
859          switch (this) {
860            case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action.";
861            case COULD: return "An action with this behavior may be included in the set of actions processed by the end user.";
862            case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included.";
863            default: return "?";
864          }
865        }
866        public String getDisplay() {
867          switch (this) {
868            case MUST: return "Must";
869            case COULD: return "Could";
870            case MUSTUNLESSDOCUMENTED: return "Must Unless Documented";
871            default: return "?";
872          }
873        }
874    }
875
876  public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> {
877    public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException {
878      if (codeString == null || "".equals(codeString))
879            if (codeString == null || "".equals(codeString))
880                return null;
881        if ("must".equals(codeString))
882          return ActionRequiredBehavior.MUST;
883        if ("could".equals(codeString))
884          return ActionRequiredBehavior.COULD;
885        if ("must-unless-documented".equals(codeString))
886          return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED;
887        throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'");
888        }
889        public Enumeration<ActionRequiredBehavior> fromType(Base code) throws FHIRException {
890          if (code == null)
891            return null;
892          if (code.isEmpty())
893            return new Enumeration<ActionRequiredBehavior>(this);
894          String codeString = ((PrimitiveType) code).asStringValue();
895          if (codeString == null || "".equals(codeString))
896            return null;
897        if ("must".equals(codeString))
898          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST);
899        if ("could".equals(codeString))
900          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD);
901        if ("must-unless-documented".equals(codeString))
902          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED);
903        throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
904        }
905    public String toCode(ActionRequiredBehavior code) {
906      if (code == ActionRequiredBehavior.MUST)
907        return "must";
908      if (code == ActionRequiredBehavior.COULD)
909        return "could";
910      if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED)
911        return "must-unless-documented";
912      return "?";
913      }
914    public String toSystem(ActionRequiredBehavior code) {
915      return code.getSystem();
916      }
917    }
918
919    public enum ActionSelectionBehavior {
920        /**
921         * Any number of the actions in the group may be chosen, from zero to all.
922         */
923        ANY, 
924        /**
925         * All the actions in the group must be selected as a single unit.
926         */
927        ALL, 
928        /**
929         * All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected.
930         */
931        ALLORNONE, 
932        /**
933         * The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group.
934         */
935        EXACTLYONE, 
936        /**
937         * The end user may choose zero or at most one of the actions in the group.
938         */
939        ATMOSTONE, 
940        /**
941         * The end user must choose a minimum of one, and as many additional as desired.
942         */
943        ONEORMORE, 
944        /**
945         * added to help the parsers
946         */
947        NULL;
948        public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException {
949            if (codeString == null || "".equals(codeString))
950                return null;
951        if ("any".equals(codeString))
952          return ANY;
953        if ("all".equals(codeString))
954          return ALL;
955        if ("all-or-none".equals(codeString))
956          return ALLORNONE;
957        if ("exactly-one".equals(codeString))
958          return EXACTLYONE;
959        if ("at-most-one".equals(codeString))
960          return ATMOSTONE;
961        if ("one-or-more".equals(codeString))
962          return ONEORMORE;
963        throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
964        }
965        public String toCode() {
966          switch (this) {
967            case ANY: return "any";
968            case ALL: return "all";
969            case ALLORNONE: return "all-or-none";
970            case EXACTLYONE: return "exactly-one";
971            case ATMOSTONE: return "at-most-one";
972            case ONEORMORE: return "one-or-more";
973            default: return "?";
974          }
975        }
976        public String getSystem() {
977          switch (this) {
978            case ANY: return "http://hl7.org/fhir/action-selection-behavior";
979            case ALL: return "http://hl7.org/fhir/action-selection-behavior";
980            case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior";
981            case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior";
982            case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior";
983            case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior";
984            default: return "?";
985          }
986        }
987        public String getDefinition() {
988          switch (this) {
989            case ANY: return "Any number of the actions in the group may be chosen, from zero to all.";
990            case ALL: return "All the actions in the group must be selected as a single unit.";
991            case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected.";
992            case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group.";
993            case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group.";
994            case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired.";
995            default: return "?";
996          }
997        }
998        public String getDisplay() {
999          switch (this) {
1000            case ANY: return "Any";
1001            case ALL: return "All";
1002            case ALLORNONE: return "All Or None";
1003            case EXACTLYONE: return "Exactly One";
1004            case ATMOSTONE: return "At Most One";
1005            case ONEORMORE: return "One Or More";
1006            default: return "?";
1007          }
1008        }
1009    }
1010
1011  public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> {
1012    public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException {
1013      if (codeString == null || "".equals(codeString))
1014            if (codeString == null || "".equals(codeString))
1015                return null;
1016        if ("any".equals(codeString))
1017          return ActionSelectionBehavior.ANY;
1018        if ("all".equals(codeString))
1019          return ActionSelectionBehavior.ALL;
1020        if ("all-or-none".equals(codeString))
1021          return ActionSelectionBehavior.ALLORNONE;
1022        if ("exactly-one".equals(codeString))
1023          return ActionSelectionBehavior.EXACTLYONE;
1024        if ("at-most-one".equals(codeString))
1025          return ActionSelectionBehavior.ATMOSTONE;
1026        if ("one-or-more".equals(codeString))
1027          return ActionSelectionBehavior.ONEORMORE;
1028        throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1029        }
1030        public Enumeration<ActionSelectionBehavior> fromType(Base code) throws FHIRException {
1031          if (code == null)
1032            return null;
1033          if (code.isEmpty())
1034            return new Enumeration<ActionSelectionBehavior>(this);
1035          String codeString = ((PrimitiveType) code).asStringValue();
1036          if (codeString == null || "".equals(codeString))
1037            return null;
1038        if ("any".equals(codeString))
1039          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY);
1040        if ("all".equals(codeString))
1041          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL);
1042        if ("all-or-none".equals(codeString))
1043          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE);
1044        if ("exactly-one".equals(codeString))
1045          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE);
1046        if ("at-most-one".equals(codeString))
1047          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE);
1048        if ("one-or-more".equals(codeString))
1049          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE);
1050        throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1051        }
1052    public String toCode(ActionSelectionBehavior code) {
1053      if (code == ActionSelectionBehavior.ANY)
1054        return "any";
1055      if (code == ActionSelectionBehavior.ALL)
1056        return "all";
1057      if (code == ActionSelectionBehavior.ALLORNONE)
1058        return "all-or-none";
1059      if (code == ActionSelectionBehavior.EXACTLYONE)
1060        return "exactly-one";
1061      if (code == ActionSelectionBehavior.ATMOSTONE)
1062        return "at-most-one";
1063      if (code == ActionSelectionBehavior.ONEORMORE)
1064        return "one-or-more";
1065      return "?";
1066      }
1067    public String toSystem(ActionSelectionBehavior code) {
1068      return code.getSystem();
1069      }
1070    }
1071
1072    public enum AdministrativeGender {
1073        /**
1074         * Male.
1075         */
1076        MALE, 
1077        /**
1078         * Female.
1079         */
1080        FEMALE, 
1081        /**
1082         * Other.
1083         */
1084        OTHER, 
1085        /**
1086         * Unknown.
1087         */
1088        UNKNOWN, 
1089        /**
1090         * added to help the parsers
1091         */
1092        NULL;
1093        public static AdministrativeGender fromCode(String codeString) throws FHIRException {
1094            if (codeString == null || "".equals(codeString))
1095                return null;
1096        if ("male".equals(codeString))
1097          return MALE;
1098        if ("female".equals(codeString))
1099          return FEMALE;
1100        if ("other".equals(codeString))
1101          return OTHER;
1102        if ("unknown".equals(codeString))
1103          return UNKNOWN;
1104        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
1105        }
1106        public String toCode() {
1107          switch (this) {
1108            case MALE: return "male";
1109            case FEMALE: return "female";
1110            case OTHER: return "other";
1111            case UNKNOWN: return "unknown";
1112            default: return "?";
1113          }
1114        }
1115        public String getSystem() {
1116          switch (this) {
1117            case MALE: return "http://hl7.org/fhir/administrative-gender";
1118            case FEMALE: return "http://hl7.org/fhir/administrative-gender";
1119            case OTHER: return "http://hl7.org/fhir/administrative-gender";
1120            case UNKNOWN: return "http://hl7.org/fhir/administrative-gender";
1121            default: return "?";
1122          }
1123        }
1124        public String getDefinition() {
1125          switch (this) {
1126            case MALE: return "Male.";
1127            case FEMALE: return "Female.";
1128            case OTHER: return "Other.";
1129            case UNKNOWN: return "Unknown.";
1130            default: return "?";
1131          }
1132        }
1133        public String getDisplay() {
1134          switch (this) {
1135            case MALE: return "Male";
1136            case FEMALE: return "Female";
1137            case OTHER: return "Other";
1138            case UNKNOWN: return "Unknown";
1139            default: return "?";
1140          }
1141        }
1142    }
1143
1144  public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> {
1145    public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException {
1146      if (codeString == null || "".equals(codeString))
1147            if (codeString == null || "".equals(codeString))
1148                return null;
1149        if ("male".equals(codeString))
1150          return AdministrativeGender.MALE;
1151        if ("female".equals(codeString))
1152          return AdministrativeGender.FEMALE;
1153        if ("other".equals(codeString))
1154          return AdministrativeGender.OTHER;
1155        if ("unknown".equals(codeString))
1156          return AdministrativeGender.UNKNOWN;
1157        throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'");
1158        }
1159        public Enumeration<AdministrativeGender> fromType(Base code) throws FHIRException {
1160          if (code == null)
1161            return null;
1162          if (code.isEmpty())
1163            return new Enumeration<AdministrativeGender>(this);
1164          String codeString = ((PrimitiveType) code).asStringValue();
1165          if (codeString == null || "".equals(codeString))
1166            return null;
1167        if ("male".equals(codeString))
1168          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE);
1169        if ("female".equals(codeString))
1170          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE);
1171        if ("other".equals(codeString))
1172          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER);
1173        if ("unknown".equals(codeString))
1174          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN);
1175        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
1176        }
1177    public String toCode(AdministrativeGender code) {
1178      if (code == AdministrativeGender.MALE)
1179        return "male";
1180      if (code == AdministrativeGender.FEMALE)
1181        return "female";
1182      if (code == AdministrativeGender.OTHER)
1183        return "other";
1184      if (code == AdministrativeGender.UNKNOWN)
1185        return "unknown";
1186      return "?";
1187      }
1188    public String toSystem(AdministrativeGender code) {
1189      return code.getSystem();
1190      }
1191    }
1192
1193    public enum BindingStrength {
1194        /**
1195         * To be conformant, the concept in this element SHALL be from the specified value set.
1196         */
1197        REQUIRED, 
1198        /**
1199         * 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.
1200         */
1201        EXTENSIBLE, 
1202        /**
1203         * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.
1204         */
1205        PREFERRED, 
1206        /**
1207         * 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.
1208         */
1209        EXAMPLE, 
1210        /**
1211         * added to help the parsers
1212         */
1213        NULL;
1214        public static BindingStrength fromCode(String codeString) throws FHIRException {
1215            if (codeString == null || "".equals(codeString))
1216                return null;
1217        if ("required".equals(codeString))
1218          return REQUIRED;
1219        if ("extensible".equals(codeString))
1220          return EXTENSIBLE;
1221        if ("preferred".equals(codeString))
1222          return PREFERRED;
1223        if ("example".equals(codeString))
1224          return EXAMPLE;
1225        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
1226        }
1227        public String toCode() {
1228          switch (this) {
1229            case REQUIRED: return "required";
1230            case EXTENSIBLE: return "extensible";
1231            case PREFERRED: return "preferred";
1232            case EXAMPLE: return "example";
1233            default: return "?";
1234          }
1235        }
1236        public String getSystem() {
1237          switch (this) {
1238            case REQUIRED: return "http://hl7.org/fhir/binding-strength";
1239            case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength";
1240            case PREFERRED: return "http://hl7.org/fhir/binding-strength";
1241            case EXAMPLE: return "http://hl7.org/fhir/binding-strength";
1242            default: return "?";
1243          }
1244        }
1245        public String getDefinition() {
1246          switch (this) {
1247            case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set.";
1248            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.";
1249            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.";
1250            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.";
1251            default: return "?";
1252          }
1253        }
1254        public String getDisplay() {
1255          switch (this) {
1256            case REQUIRED: return "Required";
1257            case EXTENSIBLE: return "Extensible";
1258            case PREFERRED: return "Preferred";
1259            case EXAMPLE: return "Example";
1260            default: return "?";
1261          }
1262        }
1263    }
1264
1265  public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> {
1266    public BindingStrength fromCode(String codeString) throws IllegalArgumentException {
1267      if (codeString == null || "".equals(codeString))
1268            if (codeString == null || "".equals(codeString))
1269                return null;
1270        if ("required".equals(codeString))
1271          return BindingStrength.REQUIRED;
1272        if ("extensible".equals(codeString))
1273          return BindingStrength.EXTENSIBLE;
1274        if ("preferred".equals(codeString))
1275          return BindingStrength.PREFERRED;
1276        if ("example".equals(codeString))
1277          return BindingStrength.EXAMPLE;
1278        throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'");
1279        }
1280        public Enumeration<BindingStrength> fromType(Base code) throws FHIRException {
1281          if (code == null)
1282            return null;
1283          if (code.isEmpty())
1284            return new Enumeration<BindingStrength>(this);
1285          String codeString = ((PrimitiveType) code).asStringValue();
1286          if (codeString == null || "".equals(codeString))
1287            return null;
1288        if ("required".equals(codeString))
1289          return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED);
1290        if ("extensible".equals(codeString))
1291          return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE);
1292        if ("preferred".equals(codeString))
1293          return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED);
1294        if ("example".equals(codeString))
1295          return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE);
1296        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
1297        }
1298    public String toCode(BindingStrength code) {
1299      if (code == BindingStrength.REQUIRED)
1300        return "required";
1301      if (code == BindingStrength.EXTENSIBLE)
1302        return "extensible";
1303      if (code == BindingStrength.PREFERRED)
1304        return "preferred";
1305      if (code == BindingStrength.EXAMPLE)
1306        return "example";
1307      return "?";
1308      }
1309    public String toSystem(BindingStrength code) {
1310      return code.getSystem();
1311      }
1312    }
1313
1314    public enum CapabilityStatementKind {
1315        /**
1316         * The CapabilityStatement instance represents the present capabilities of a specific system instance.  This is the kind returned by /metadata for a FHIR server end-point.
1317         */
1318        INSTANCE, 
1319        /**
1320         * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.
1321         */
1322        CAPABILITY, 
1323        /**
1324         * The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'.
1325         */
1326        REQUIREMENTS, 
1327        /**
1328         * added to help the parsers
1329         */
1330        NULL;
1331        public static CapabilityStatementKind fromCode(String codeString) throws FHIRException {
1332            if (codeString == null || "".equals(codeString))
1333                return null;
1334        if ("instance".equals(codeString))
1335          return INSTANCE;
1336        if ("capability".equals(codeString))
1337          return CAPABILITY;
1338        if ("requirements".equals(codeString))
1339          return REQUIREMENTS;
1340        throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
1341        }
1342        public String toCode() {
1343          switch (this) {
1344            case INSTANCE: return "instance";
1345            case CAPABILITY: return "capability";
1346            case REQUIREMENTS: return "requirements";
1347            default: return "?";
1348          }
1349        }
1350        public String getSystem() {
1351          switch (this) {
1352            case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind";
1353            case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind";
1354            case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind";
1355            default: return "?";
1356          }
1357        }
1358        public String getDefinition() {
1359          switch (this) {
1360            case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance.  This is the kind returned by /metadata for a FHIR server end-point.";
1361            case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.";
1362            case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'.";
1363            default: return "?";
1364          }
1365        }
1366        public String getDisplay() {
1367          switch (this) {
1368            case INSTANCE: return "Instance";
1369            case CAPABILITY: return "Capability";
1370            case REQUIREMENTS: return "Requirements";
1371            default: return "?";
1372          }
1373        }
1374    }
1375
1376  public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> {
1377    public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException {
1378      if (codeString == null || "".equals(codeString))
1379            if (codeString == null || "".equals(codeString))
1380                return null;
1381        if ("instance".equals(codeString))
1382          return CapabilityStatementKind.INSTANCE;
1383        if ("capability".equals(codeString))
1384          return CapabilityStatementKind.CAPABILITY;
1385        if ("requirements".equals(codeString))
1386          return CapabilityStatementKind.REQUIREMENTS;
1387        throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'");
1388        }
1389        public Enumeration<CapabilityStatementKind> fromType(Base code) throws FHIRException {
1390          if (code == null)
1391            return null;
1392          if (code.isEmpty())
1393            return new Enumeration<CapabilityStatementKind>(this);
1394          String codeString = ((PrimitiveType) code).asStringValue();
1395          if (codeString == null || "".equals(codeString))
1396            return null;
1397        if ("instance".equals(codeString))
1398          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE);
1399        if ("capability".equals(codeString))
1400          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY);
1401        if ("requirements".equals(codeString))
1402          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS);
1403        throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
1404        }
1405    public String toCode(CapabilityStatementKind code) {
1406      if (code == CapabilityStatementKind.INSTANCE)
1407        return "instance";
1408      if (code == CapabilityStatementKind.CAPABILITY)
1409        return "capability";
1410      if (code == CapabilityStatementKind.REQUIREMENTS)
1411        return "requirements";
1412      return "?";
1413      }
1414    public String toSystem(CapabilityStatementKind code) {
1415      return code.getSystem();
1416      }
1417    }
1418
1419    public enum ClaimProcessingCodes {
1420        /**
1421         * null
1422         */
1423        QUEUED, 
1424        /**
1425         * The processing completed without errors.
1426         */
1427        COMPLETE, 
1428        /**
1429         * The processing identified errors.
1430         */
1431        ERROR, 
1432        /**
1433         * No errors have been detected and some of the adjudication has been performed.
1434         */
1435        PARTIAL, 
1436        /**
1437         * added to help the parsers
1438         */
1439        NULL;
1440        public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException {
1441            if (codeString == null || "".equals(codeString))
1442                return null;
1443        if ("queued".equals(codeString))
1444          return QUEUED;
1445        if ("complete".equals(codeString))
1446          return COMPLETE;
1447        if ("error".equals(codeString))
1448          return ERROR;
1449        if ("partial".equals(codeString))
1450          return PARTIAL;
1451        throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1452        }
1453        public String toCode() {
1454          switch (this) {
1455            case QUEUED: return "queued";
1456            case COMPLETE: return "complete";
1457            case ERROR: return "error";
1458            case PARTIAL: return "partial";
1459            default: return "?";
1460          }
1461        }
1462        public String getSystem() {
1463          switch (this) {
1464            case QUEUED: return "http://hl7.org/fhir/remittance-outcome";
1465            case COMPLETE: return "http://hl7.org/fhir/remittance-outcome";
1466            case ERROR: return "http://hl7.org/fhir/remittance-outcome";
1467            case PARTIAL: return "http://hl7.org/fhir/remittance-outcome";
1468            default: return "?";
1469          }
1470        }
1471        public String getDefinition() {
1472          switch (this) {
1473            case QUEUED: return "";
1474            case COMPLETE: return "The processing completed without errors.";
1475            case ERROR: return "The processing identified errors.";
1476            case PARTIAL: return "No errors have been detected and some of the adjudication has been performed.";
1477            default: return "?";
1478          }
1479        }
1480        public String getDisplay() {
1481          switch (this) {
1482            case QUEUED: return "Queued";
1483            case COMPLETE: return "Processing Complete";
1484            case ERROR: return "Error";
1485            case PARTIAL: return "Partial Processing";
1486            default: return "?";
1487          }
1488        }
1489    }
1490
1491  public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> {
1492    public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException {
1493      if (codeString == null || "".equals(codeString))
1494            if (codeString == null || "".equals(codeString))
1495                return null;
1496        if ("queued".equals(codeString))
1497          return ClaimProcessingCodes.QUEUED;
1498        if ("complete".equals(codeString))
1499          return ClaimProcessingCodes.COMPLETE;
1500        if ("error".equals(codeString))
1501          return ClaimProcessingCodes.ERROR;
1502        if ("partial".equals(codeString))
1503          return ClaimProcessingCodes.PARTIAL;
1504        throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1505        }
1506        public Enumeration<ClaimProcessingCodes> fromType(Base code) throws FHIRException {
1507          if (code == null)
1508            return null;
1509          if (code.isEmpty())
1510            return new Enumeration<ClaimProcessingCodes>(this);
1511          String codeString = ((PrimitiveType) code).asStringValue();
1512          if (codeString == null || "".equals(codeString))
1513            return null;
1514        if ("queued".equals(codeString))
1515          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED);
1516        if ("complete".equals(codeString))
1517          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE);
1518        if ("error".equals(codeString))
1519          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR);
1520        if ("partial".equals(codeString))
1521          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL);
1522        throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1523        }
1524    public String toCode(ClaimProcessingCodes code) {
1525      if (code == ClaimProcessingCodes.QUEUED)
1526        return "queued";
1527      if (code == ClaimProcessingCodes.COMPLETE)
1528        return "complete";
1529      if (code == ClaimProcessingCodes.ERROR)
1530        return "error";
1531      if (code == ClaimProcessingCodes.PARTIAL)
1532        return "partial";
1533      return "?";
1534      }
1535    public String toSystem(ClaimProcessingCodes code) {
1536      return code.getSystem();
1537      }
1538    }
1539
1540    public enum CompartmentType {
1541        /**
1542         * The compartment definition is for the patient compartment.
1543         */
1544        PATIENT, 
1545        /**
1546         * The compartment definition is for the encounter compartment.
1547         */
1548        ENCOUNTER, 
1549        /**
1550         * The compartment definition is for the related-person compartment.
1551         */
1552        RELATEDPERSON, 
1553        /**
1554         * The compartment definition is for the practitioner compartment.
1555         */
1556        PRACTITIONER, 
1557        /**
1558         * The compartment definition is for the device compartment.
1559         */
1560        DEVICE, 
1561        /**
1562         * added to help the parsers
1563         */
1564        NULL;
1565        public static CompartmentType fromCode(String codeString) throws FHIRException {
1566            if (codeString == null || "".equals(codeString))
1567                return null;
1568        if ("Patient".equals(codeString))
1569          return PATIENT;
1570        if ("Encounter".equals(codeString))
1571          return ENCOUNTER;
1572        if ("RelatedPerson".equals(codeString))
1573          return RELATEDPERSON;
1574        if ("Practitioner".equals(codeString))
1575          return PRACTITIONER;
1576        if ("Device".equals(codeString))
1577          return DEVICE;
1578        throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
1579        }
1580        public String toCode() {
1581          switch (this) {
1582            case PATIENT: return "Patient";
1583            case ENCOUNTER: return "Encounter";
1584            case RELATEDPERSON: return "RelatedPerson";
1585            case PRACTITIONER: return "Practitioner";
1586            case DEVICE: return "Device";
1587            default: return "?";
1588          }
1589        }
1590        public String getSystem() {
1591          switch (this) {
1592            case PATIENT: return "http://hl7.org/fhir/compartment-type";
1593            case ENCOUNTER: return "http://hl7.org/fhir/compartment-type";
1594            case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type";
1595            case PRACTITIONER: return "http://hl7.org/fhir/compartment-type";
1596            case DEVICE: return "http://hl7.org/fhir/compartment-type";
1597            default: return "?";
1598          }
1599        }
1600        public String getDefinition() {
1601          switch (this) {
1602            case PATIENT: return "The compartment definition is for the patient compartment.";
1603            case ENCOUNTER: return "The compartment definition is for the encounter compartment.";
1604            case RELATEDPERSON: return "The compartment definition is for the related-person compartment.";
1605            case PRACTITIONER: return "The compartment definition is for the practitioner compartment.";
1606            case DEVICE: return "The compartment definition is for the device compartment.";
1607            default: return "?";
1608          }
1609        }
1610        public String getDisplay() {
1611          switch (this) {
1612            case PATIENT: return "Patient";
1613            case ENCOUNTER: return "Encounter";
1614            case RELATEDPERSON: return "RelatedPerson";
1615            case PRACTITIONER: return "Practitioner";
1616            case DEVICE: return "Device";
1617            default: return "?";
1618          }
1619        }
1620    }
1621
1622  public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> {
1623    public CompartmentType fromCode(String codeString) throws IllegalArgumentException {
1624      if (codeString == null || "".equals(codeString))
1625            if (codeString == null || "".equals(codeString))
1626                return null;
1627        if ("Patient".equals(codeString))
1628          return CompartmentType.PATIENT;
1629        if ("Encounter".equals(codeString))
1630          return CompartmentType.ENCOUNTER;
1631        if ("RelatedPerson".equals(codeString))
1632          return CompartmentType.RELATEDPERSON;
1633        if ("Practitioner".equals(codeString))
1634          return CompartmentType.PRACTITIONER;
1635        if ("Device".equals(codeString))
1636          return CompartmentType.DEVICE;
1637        throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'");
1638        }
1639        public Enumeration<CompartmentType> fromType(Base code) throws FHIRException {
1640          if (code == null)
1641            return null;
1642          if (code.isEmpty())
1643            return new Enumeration<CompartmentType>(this);
1644          String codeString = ((PrimitiveType) code).asStringValue();
1645          if (codeString == null || "".equals(codeString))
1646            return null;
1647        if ("Patient".equals(codeString))
1648          return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT);
1649        if ("Encounter".equals(codeString))
1650          return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER);
1651        if ("RelatedPerson".equals(codeString))
1652          return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON);
1653        if ("Practitioner".equals(codeString))
1654          return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER);
1655        if ("Device".equals(codeString))
1656          return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE);
1657        throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
1658        }
1659    public String toCode(CompartmentType code) {
1660      if (code == CompartmentType.PATIENT)
1661        return "Patient";
1662      if (code == CompartmentType.ENCOUNTER)
1663        return "Encounter";
1664      if (code == CompartmentType.RELATEDPERSON)
1665        return "RelatedPerson";
1666      if (code == CompartmentType.PRACTITIONER)
1667        return "Practitioner";
1668      if (code == CompartmentType.DEVICE)
1669        return "Device";
1670      return "?";
1671      }
1672    public String toSystem(CompartmentType code) {
1673      return code.getSystem();
1674      }
1675    }
1676
1677    public enum CompositionStatus {
1678        /**
1679         * This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified.
1680         */
1681        PRELIMINARY, 
1682        /**
1683         * This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.
1684         */
1685        FINAL, 
1686        /**
1687         * The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as "final" and the composition is complete and verified by an authorized person.
1688         */
1689        AMENDED, 
1690        /**
1691         * The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.
1692         */
1693        ENTEREDINERROR, 
1694        /**
1695         * added to help the parsers
1696         */
1697        NULL;
1698        public static CompositionStatus fromCode(String codeString) throws FHIRException {
1699            if (codeString == null || "".equals(codeString))
1700                return null;
1701        if ("preliminary".equals(codeString))
1702          return PRELIMINARY;
1703        if ("final".equals(codeString))
1704          return FINAL;
1705        if ("amended".equals(codeString))
1706          return AMENDED;
1707        if ("entered-in-error".equals(codeString))
1708          return ENTEREDINERROR;
1709        throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
1710        }
1711        public String toCode() {
1712          switch (this) {
1713            case PRELIMINARY: return "preliminary";
1714            case FINAL: return "final";
1715            case AMENDED: return "amended";
1716            case ENTEREDINERROR: return "entered-in-error";
1717            default: return "?";
1718          }
1719        }
1720        public String getSystem() {
1721          switch (this) {
1722            case PRELIMINARY: return "http://hl7.org/fhir/composition-status";
1723            case FINAL: return "http://hl7.org/fhir/composition-status";
1724            case AMENDED: return "http://hl7.org/fhir/composition-status";
1725            case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status";
1726            default: return "?";
1727          }
1728        }
1729        public String getDefinition() {
1730          switch (this) {
1731            case PRELIMINARY: return "This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified.";
1732            case FINAL: return "This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.";
1733            case AMENDED: return "The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as \"final\" and the composition is complete and verified by an authorized person.";
1734            case ENTEREDINERROR: return "The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.";
1735            default: return "?";
1736          }
1737        }
1738        public String getDisplay() {
1739          switch (this) {
1740            case PRELIMINARY: return "Preliminary";
1741            case FINAL: return "Final";
1742            case AMENDED: return "Amended";
1743            case ENTEREDINERROR: return "Entered in Error";
1744            default: return "?";
1745          }
1746        }
1747    }
1748
1749  public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> {
1750    public CompositionStatus fromCode(String codeString) throws IllegalArgumentException {
1751      if (codeString == null || "".equals(codeString))
1752            if (codeString == null || "".equals(codeString))
1753                return null;
1754        if ("preliminary".equals(codeString))
1755          return CompositionStatus.PRELIMINARY;
1756        if ("final".equals(codeString))
1757          return CompositionStatus.FINAL;
1758        if ("amended".equals(codeString))
1759          return CompositionStatus.AMENDED;
1760        if ("entered-in-error".equals(codeString))
1761          return CompositionStatus.ENTEREDINERROR;
1762        throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'");
1763        }
1764        public Enumeration<CompositionStatus> fromType(Base code) throws FHIRException {
1765          if (code == null)
1766            return null;
1767          if (code.isEmpty())
1768            return new Enumeration<CompositionStatus>(this);
1769          String codeString = ((PrimitiveType) code).asStringValue();
1770          if (codeString == null || "".equals(codeString))
1771            return null;
1772        if ("preliminary".equals(codeString))
1773          return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY);
1774        if ("final".equals(codeString))
1775          return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL);
1776        if ("amended".equals(codeString))
1777          return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED);
1778        if ("entered-in-error".equals(codeString))
1779          return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR);
1780        throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
1781        }
1782    public String toCode(CompositionStatus code) {
1783      if (code == CompositionStatus.PRELIMINARY)
1784        return "preliminary";
1785      if (code == CompositionStatus.FINAL)
1786        return "final";
1787      if (code == CompositionStatus.AMENDED)
1788        return "amended";
1789      if (code == CompositionStatus.ENTEREDINERROR)
1790        return "entered-in-error";
1791      return "?";
1792      }
1793    public String toSystem(CompositionStatus code) {
1794      return code.getSystem();
1795      }
1796    }
1797
1798    public enum ConceptMapRelationship {
1799        /**
1800         * The concepts are related to each other, but the exact relationship is not known.
1801         */
1802        RELATEDTO, 
1803        /**
1804         * The definitions of the concepts mean the same thing.
1805         */
1806        EQUIVALENT, 
1807        /**
1808         * The target concept is broader in meaning than the source concept.
1809         */
1810        BROADER, 
1811        /**
1812         * The target concept is narrower in meaning than the source concept.
1813         */
1814        NARROWER, 
1815        /**
1816         * This is an explicit assertion that the target concept is not related to the source concept.
1817         */
1818        NOTRELATEDTO, 
1819        /**
1820         * added to help the parsers
1821         */
1822        NULL;
1823        public static ConceptMapRelationship fromCode(String codeString) throws FHIRException {
1824            if (codeString == null || "".equals(codeString))
1825                return null;
1826        if ("related-to".equals(codeString))
1827          return RELATEDTO;
1828        if ("equivalent".equals(codeString))
1829          return EQUIVALENT;
1830        if ("broader".equals(codeString))
1831          return BROADER;
1832        if ("narrower".equals(codeString))
1833          return NARROWER;
1834        if ("not-related-to".equals(codeString))
1835          return NOTRELATEDTO;
1836        throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
1837        }
1838        public String toCode() {
1839          switch (this) {
1840            case RELATEDTO: return "related-to";
1841            case EQUIVALENT: return "equivalent";
1842            case BROADER: return "broader";
1843            case NARROWER: return "narrower";
1844            case NOTRELATEDTO: return "not-related-to";
1845            default: return "?";
1846          }
1847        }
1848        public String getSystem() {
1849          switch (this) {
1850            case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
1851            case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship";
1852            case BROADER: return "http://hl7.org/fhir/concept-map-relationship";
1853            case NARROWER: return "http://hl7.org/fhir/concept-map-relationship";
1854            case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
1855            default: return "?";
1856          }
1857        }
1858        public String getDefinition() {
1859          switch (this) {
1860            case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known.";
1861            case EQUIVALENT: return "The definitions of the concepts mean the same thing.";
1862            case BROADER: return "The target concept is broader in meaning than the source concept.";
1863            case NARROWER: return "The target concept is narrower in meaning than the source concept.";
1864            case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept.";
1865            default: return "?";
1866          }
1867        }
1868        public String getDisplay() {
1869          switch (this) {
1870            case RELATEDTO: return "Related To";
1871            case EQUIVALENT: return "Equivalent";
1872            case BROADER: return "Broader";
1873            case NARROWER: return "Narrower";
1874            case NOTRELATEDTO: return "Not Related To";
1875            default: return "?";
1876          }
1877        }
1878    }
1879
1880  public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> {
1881    public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException {
1882      if (codeString == null || "".equals(codeString))
1883            if (codeString == null || "".equals(codeString))
1884                return null;
1885        if ("related-to".equals(codeString))
1886          return ConceptMapRelationship.RELATEDTO;
1887        if ("equivalent".equals(codeString))
1888          return ConceptMapRelationship.EQUIVALENT;
1889        if ("broader".equals(codeString))
1890          return ConceptMapRelationship.BROADER;
1891        if ("narrower".equals(codeString))
1892          return ConceptMapRelationship.NARROWER;
1893        if ("not-related-to".equals(codeString))
1894          return ConceptMapRelationship.NOTRELATEDTO;
1895        throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'");
1896        }
1897        public Enumeration<ConceptMapRelationship> fromType(Base code) throws FHIRException {
1898          if (code == null)
1899            return null;
1900          if (code.isEmpty())
1901            return new Enumeration<ConceptMapRelationship>(this);
1902          String codeString = ((PrimitiveType) code).asStringValue();
1903          if (codeString == null || "".equals(codeString))
1904            return null;
1905        if ("related-to".equals(codeString))
1906          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO);
1907        if ("equivalent".equals(codeString))
1908          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT);
1909        if ("broader".equals(codeString))
1910          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.BROADER);
1911        if ("narrower".equals(codeString))
1912          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NARROWER);
1913        if ("not-related-to".equals(codeString))
1914          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO);
1915        throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
1916        }
1917    public String toCode(ConceptMapRelationship code) {
1918      if (code == ConceptMapRelationship.RELATEDTO)
1919        return "related-to";
1920      if (code == ConceptMapRelationship.EQUIVALENT)
1921        return "equivalent";
1922      if (code == ConceptMapRelationship.BROADER)
1923        return "broader";
1924      if (code == ConceptMapRelationship.NARROWER)
1925        return "narrower";
1926      if (code == ConceptMapRelationship.NOTRELATEDTO)
1927        return "not-related-to";
1928      return "?";
1929      }
1930    public String toSystem(ConceptMapRelationship code) {
1931      return code.getSystem();
1932      }
1933    }
1934
1935    public enum DaysOfWeek {
1936        /**
1937         * Monday.
1938         */
1939        MON, 
1940        /**
1941         * Tuesday.
1942         */
1943        TUE, 
1944        /**
1945         * Wednesday.
1946         */
1947        WED, 
1948        /**
1949         * Thursday.
1950         */
1951        THU, 
1952        /**
1953         * Friday.
1954         */
1955        FRI, 
1956        /**
1957         * Saturday.
1958         */
1959        SAT, 
1960        /**
1961         * Sunday.
1962         */
1963        SUN, 
1964        /**
1965         * added to help the parsers
1966         */
1967        NULL;
1968        public static DaysOfWeek fromCode(String codeString) throws FHIRException {
1969            if (codeString == null || "".equals(codeString))
1970                return null;
1971        if ("mon".equals(codeString))
1972          return MON;
1973        if ("tue".equals(codeString))
1974          return TUE;
1975        if ("wed".equals(codeString))
1976          return WED;
1977        if ("thu".equals(codeString))
1978          return THU;
1979        if ("fri".equals(codeString))
1980          return FRI;
1981        if ("sat".equals(codeString))
1982          return SAT;
1983        if ("sun".equals(codeString))
1984          return SUN;
1985        throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'");
1986        }
1987        public String toCode() {
1988          switch (this) {
1989            case MON: return "mon";
1990            case TUE: return "tue";
1991            case WED: return "wed";
1992            case THU: return "thu";
1993            case FRI: return "fri";
1994            case SAT: return "sat";
1995            case SUN: return "sun";
1996            default: return "?";
1997          }
1998        }
1999        public String getSystem() {
2000          switch (this) {
2001            case MON: return "http://hl7.org/fhir/days-of-week";
2002            case TUE: return "http://hl7.org/fhir/days-of-week";
2003            case WED: return "http://hl7.org/fhir/days-of-week";
2004            case THU: return "http://hl7.org/fhir/days-of-week";
2005            case FRI: return "http://hl7.org/fhir/days-of-week";
2006            case SAT: return "http://hl7.org/fhir/days-of-week";
2007            case SUN: return "http://hl7.org/fhir/days-of-week";
2008            default: return "?";
2009          }
2010        }
2011        public String getDefinition() {
2012          switch (this) {
2013            case MON: return "Monday.";
2014            case TUE: return "Tuesday.";
2015            case WED: return "Wednesday.";
2016            case THU: return "Thursday.";
2017            case FRI: return "Friday.";
2018            case SAT: return "Saturday.";
2019            case SUN: return "Sunday.";
2020            default: return "?";
2021          }
2022        }
2023        public String getDisplay() {
2024          switch (this) {
2025            case MON: return "Monday";
2026            case TUE: return "Tuesday";
2027            case WED: return "Wednesday";
2028            case THU: return "Thursday";
2029            case FRI: return "Friday";
2030            case SAT: return "Saturday";
2031            case SUN: return "Sunday";
2032            default: return "?";
2033          }
2034        }
2035    }
2036
2037  public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> {
2038    public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException {
2039      if (codeString == null || "".equals(codeString))
2040            if (codeString == null || "".equals(codeString))
2041                return null;
2042        if ("mon".equals(codeString))
2043          return DaysOfWeek.MON;
2044        if ("tue".equals(codeString))
2045          return DaysOfWeek.TUE;
2046        if ("wed".equals(codeString))
2047          return DaysOfWeek.WED;
2048        if ("thu".equals(codeString))
2049          return DaysOfWeek.THU;
2050        if ("fri".equals(codeString))
2051          return DaysOfWeek.FRI;
2052        if ("sat".equals(codeString))
2053          return DaysOfWeek.SAT;
2054        if ("sun".equals(codeString))
2055          return DaysOfWeek.SUN;
2056        throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'");
2057        }
2058        public Enumeration<DaysOfWeek> fromType(Base code) throws FHIRException {
2059          if (code == null)
2060            return null;
2061          if (code.isEmpty())
2062            return new Enumeration<DaysOfWeek>(this);
2063          String codeString = ((PrimitiveType) code).asStringValue();
2064          if (codeString == null || "".equals(codeString))
2065            return null;
2066        if ("mon".equals(codeString))
2067          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON);
2068        if ("tue".equals(codeString))
2069          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE);
2070        if ("wed".equals(codeString))
2071          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED);
2072        if ("thu".equals(codeString))
2073          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU);
2074        if ("fri".equals(codeString))
2075          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI);
2076        if ("sat".equals(codeString))
2077          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT);
2078        if ("sun".equals(codeString))
2079          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN);
2080        throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'");
2081        }
2082    public String toCode(DaysOfWeek code) {
2083      if (code == DaysOfWeek.MON)
2084        return "mon";
2085      if (code == DaysOfWeek.TUE)
2086        return "tue";
2087      if (code == DaysOfWeek.WED)
2088        return "wed";
2089      if (code == DaysOfWeek.THU)
2090        return "thu";
2091      if (code == DaysOfWeek.FRI)
2092        return "fri";
2093      if (code == DaysOfWeek.SAT)
2094        return "sat";
2095      if (code == DaysOfWeek.SUN)
2096        return "sun";
2097      return "?";
2098      }
2099    public String toSystem(DaysOfWeek code) {
2100      return code.getSystem();
2101      }
2102    }
2103
2104    public enum DeviceNameType {
2105        /**
2106         * UDI Label name.
2107         */
2108        UDILABELNAME, 
2109        /**
2110         * User Friendly name.
2111         */
2112        USERFRIENDLYNAME, 
2113        /**
2114         * Patient Reported name.
2115         */
2116        PATIENTREPORTEDNAME, 
2117        /**
2118         * Manufacturer name.
2119         */
2120        MANUFACTURERNAME, 
2121        /**
2122         * Model name.
2123         */
2124        MODELNAME, 
2125        /**
2126         * other.
2127         */
2128        OTHER, 
2129        /**
2130         * added to help the parsers
2131         */
2132        NULL;
2133        public static DeviceNameType fromCode(String codeString) throws FHIRException {
2134            if (codeString == null || "".equals(codeString))
2135                return null;
2136        if ("udi-label-name".equals(codeString))
2137          return UDILABELNAME;
2138        if ("user-friendly-name".equals(codeString))
2139          return USERFRIENDLYNAME;
2140        if ("patient-reported-name".equals(codeString))
2141          return PATIENTREPORTEDNAME;
2142        if ("manufacturer-name".equals(codeString))
2143          return MANUFACTURERNAME;
2144        if ("model-name".equals(codeString))
2145          return MODELNAME;
2146        if ("other".equals(codeString))
2147          return OTHER;
2148        throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'");
2149        }
2150        public String toCode() {
2151          switch (this) {
2152            case UDILABELNAME: return "udi-label-name";
2153            case USERFRIENDLYNAME: return "user-friendly-name";
2154            case PATIENTREPORTEDNAME: return "patient-reported-name";
2155            case MANUFACTURERNAME: return "manufacturer-name";
2156            case MODELNAME: return "model-name";
2157            case OTHER: return "other";
2158            default: return "?";
2159          }
2160        }
2161        public String getSystem() {
2162          switch (this) {
2163            case UDILABELNAME: return "http://hl7.org/fhir/device-nametype";
2164            case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype";
2165            case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype";
2166            case MANUFACTURERNAME: return "http://hl7.org/fhir/device-nametype";
2167            case MODELNAME: return "http://hl7.org/fhir/device-nametype";
2168            case OTHER: return "http://hl7.org/fhir/device-nametype";
2169            default: return "?";
2170          }
2171        }
2172        public String getDefinition() {
2173          switch (this) {
2174            case UDILABELNAME: return "UDI Label name.";
2175            case USERFRIENDLYNAME: return "User Friendly name.";
2176            case PATIENTREPORTEDNAME: return "Patient Reported name.";
2177            case MANUFACTURERNAME: return "Manufacturer name.";
2178            case MODELNAME: return "Model name.";
2179            case OTHER: return "other.";
2180            default: return "?";
2181          }
2182        }
2183        public String getDisplay() {
2184          switch (this) {
2185            case UDILABELNAME: return "UDI Label name";
2186            case USERFRIENDLYNAME: return "User Friendly name";
2187            case PATIENTREPORTEDNAME: return "Patient Reported name";
2188            case MANUFACTURERNAME: return "Manufacturer name";
2189            case MODELNAME: return "Model name";
2190            case OTHER: return "other";
2191            default: return "?";
2192          }
2193        }
2194    }
2195
2196  public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> {
2197    public DeviceNameType fromCode(String codeString) throws IllegalArgumentException {
2198      if (codeString == null || "".equals(codeString))
2199            if (codeString == null || "".equals(codeString))
2200                return null;
2201        if ("udi-label-name".equals(codeString))
2202          return DeviceNameType.UDILABELNAME;
2203        if ("user-friendly-name".equals(codeString))
2204          return DeviceNameType.USERFRIENDLYNAME;
2205        if ("patient-reported-name".equals(codeString))
2206          return DeviceNameType.PATIENTREPORTEDNAME;
2207        if ("manufacturer-name".equals(codeString))
2208          return DeviceNameType.MANUFACTURERNAME;
2209        if ("model-name".equals(codeString))
2210          return DeviceNameType.MODELNAME;
2211        if ("other".equals(codeString))
2212          return DeviceNameType.OTHER;
2213        throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'");
2214        }
2215        public Enumeration<DeviceNameType> fromType(Base code) throws FHIRException {
2216          if (code == null)
2217            return null;
2218          if (code.isEmpty())
2219            return new Enumeration<DeviceNameType>(this);
2220          String codeString = ((PrimitiveType) code).asStringValue();
2221          if (codeString == null || "".equals(codeString))
2222            return null;
2223        if ("udi-label-name".equals(codeString))
2224          return new Enumeration<DeviceNameType>(this, DeviceNameType.UDILABELNAME);
2225        if ("user-friendly-name".equals(codeString))
2226          return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME);
2227        if ("patient-reported-name".equals(codeString))
2228          return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME);
2229        if ("manufacturer-name".equals(codeString))
2230          return new Enumeration<DeviceNameType>(this, DeviceNameType.MANUFACTURERNAME);
2231        if ("model-name".equals(codeString))
2232          return new Enumeration<DeviceNameType>(this, DeviceNameType.MODELNAME);
2233        if ("other".equals(codeString))
2234          return new Enumeration<DeviceNameType>(this, DeviceNameType.OTHER);
2235        throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'");
2236        }
2237    public String toCode(DeviceNameType code) {
2238      if (code == DeviceNameType.UDILABELNAME)
2239        return "udi-label-name";
2240      if (code == DeviceNameType.USERFRIENDLYNAME)
2241        return "user-friendly-name";
2242      if (code == DeviceNameType.PATIENTREPORTEDNAME)
2243        return "patient-reported-name";
2244      if (code == DeviceNameType.MANUFACTURERNAME)
2245        return "manufacturer-name";
2246      if (code == DeviceNameType.MODELNAME)
2247        return "model-name";
2248      if (code == DeviceNameType.OTHER)
2249        return "other";
2250      return "?";
2251      }
2252    public String toSystem(DeviceNameType code) {
2253      return code.getSystem();
2254      }
2255    }
2256
2257    public enum DocumentReferenceStatus {
2258        /**
2259         * This is the current reference for this document.
2260         */
2261        CURRENT, 
2262        /**
2263         * This reference has been superseded by another reference.
2264         */
2265        SUPERSEDED, 
2266        /**
2267         * This reference was created in error.
2268         */
2269        ENTEREDINERROR, 
2270        /**
2271         * added to help the parsers
2272         */
2273        NULL;
2274        public static DocumentReferenceStatus fromCode(String codeString) throws FHIRException {
2275            if (codeString == null || "".equals(codeString))
2276                return null;
2277        if ("current".equals(codeString))
2278          return CURRENT;
2279        if ("superseded".equals(codeString))
2280          return SUPERSEDED;
2281        if ("entered-in-error".equals(codeString))
2282          return ENTEREDINERROR;
2283        throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2284        }
2285        public String toCode() {
2286          switch (this) {
2287            case CURRENT: return "current";
2288            case SUPERSEDED: return "superseded";
2289            case ENTEREDINERROR: return "entered-in-error";
2290            default: return "?";
2291          }
2292        }
2293        public String getSystem() {
2294          switch (this) {
2295            case CURRENT: return "http://hl7.org/fhir/document-reference-status";
2296            case SUPERSEDED: return "http://hl7.org/fhir/document-reference-status";
2297            case ENTEREDINERROR: return "http://hl7.org/fhir/document-reference-status";
2298            default: return "?";
2299          }
2300        }
2301        public String getDefinition() {
2302          switch (this) {
2303            case CURRENT: return "This is the current reference for this document.";
2304            case SUPERSEDED: return "This reference has been superseded by another reference.";
2305            case ENTEREDINERROR: return "This reference was created in error.";
2306            default: return "?";
2307          }
2308        }
2309        public String getDisplay() {
2310          switch (this) {
2311            case CURRENT: return "Current";
2312            case SUPERSEDED: return "Superseded";
2313            case ENTEREDINERROR: return "Entered in Error";
2314            default: return "?";
2315          }
2316        }
2317    }
2318
2319  public static class DocumentReferenceStatusEnumFactory implements EnumFactory<DocumentReferenceStatus> {
2320    public DocumentReferenceStatus fromCode(String codeString) throws IllegalArgumentException {
2321      if (codeString == null || "".equals(codeString))
2322            if (codeString == null || "".equals(codeString))
2323                return null;
2324        if ("current".equals(codeString))
2325          return DocumentReferenceStatus.CURRENT;
2326        if ("superseded".equals(codeString))
2327          return DocumentReferenceStatus.SUPERSEDED;
2328        if ("entered-in-error".equals(codeString))
2329          return DocumentReferenceStatus.ENTEREDINERROR;
2330        throw new IllegalArgumentException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2331        }
2332        public Enumeration<DocumentReferenceStatus> fromType(Base code) throws FHIRException {
2333          if (code == null)
2334            return null;
2335          if (code.isEmpty())
2336            return new Enumeration<DocumentReferenceStatus>(this);
2337          String codeString = ((PrimitiveType) code).asStringValue();
2338          if (codeString == null || "".equals(codeString))
2339            return null;
2340        if ("current".equals(codeString))
2341          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.CURRENT);
2342        if ("superseded".equals(codeString))
2343          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.SUPERSEDED);
2344        if ("entered-in-error".equals(codeString))
2345          return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.ENTEREDINERROR);
2346        throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'");
2347        }
2348    public String toCode(DocumentReferenceStatus code) {
2349      if (code == DocumentReferenceStatus.CURRENT)
2350        return "current";
2351      if (code == DocumentReferenceStatus.SUPERSEDED)
2352        return "superseded";
2353      if (code == DocumentReferenceStatus.ENTEREDINERROR)
2354        return "entered-in-error";
2355      return "?";
2356      }
2357    public String toSystem(DocumentReferenceStatus code) {
2358      return code.getSystem();
2359      }
2360    }
2361
2362    public enum DocumentRelationshipType {
2363        /**
2364         * This document logically replaces or supersedes the target document.
2365         */
2366        REPLACES, 
2367        /**
2368         * This document was generated by transforming the target document (e.g. format or language conversion).
2369         */
2370        TRANSFORMS, 
2371        /**
2372         * This document is a signature of the target document.
2373         */
2374        SIGNS, 
2375        /**
2376         * This document adds additional information to the target document.
2377         */
2378        APPENDS, 
2379        /**
2380         * added to help the parsers
2381         */
2382        NULL;
2383        public static DocumentRelationshipType fromCode(String codeString) throws FHIRException {
2384            if (codeString == null || "".equals(codeString))
2385                return null;
2386        if ("replaces".equals(codeString))
2387          return REPLACES;
2388        if ("transforms".equals(codeString))
2389          return TRANSFORMS;
2390        if ("signs".equals(codeString))
2391          return SIGNS;
2392        if ("appends".equals(codeString))
2393          return APPENDS;
2394        throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'");
2395        }
2396        public String toCode() {
2397          switch (this) {
2398            case REPLACES: return "replaces";
2399            case TRANSFORMS: return "transforms";
2400            case SIGNS: return "signs";
2401            case APPENDS: return "appends";
2402            default: return "?";
2403          }
2404        }
2405        public String getSystem() {
2406          switch (this) {
2407            case REPLACES: return "http://hl7.org/fhir/document-relationship-type";
2408            case TRANSFORMS: return "http://hl7.org/fhir/document-relationship-type";
2409            case SIGNS: return "http://hl7.org/fhir/document-relationship-type";
2410            case APPENDS: return "http://hl7.org/fhir/document-relationship-type";
2411            default: return "?";
2412          }
2413        }
2414        public String getDefinition() {
2415          switch (this) {
2416            case REPLACES: return "This document logically replaces or supersedes the target document.";
2417            case TRANSFORMS: return "This document was generated by transforming the target document (e.g. format or language conversion).";
2418            case SIGNS: return "This document is a signature of the target document.";
2419            case APPENDS: return "This document adds additional information to the target document.";
2420            default: return "?";
2421          }
2422        }
2423        public String getDisplay() {
2424          switch (this) {
2425            case REPLACES: return "Replaces";
2426            case TRANSFORMS: return "Transforms";
2427            case SIGNS: return "Signs";
2428            case APPENDS: return "Appends";
2429            default: return "?";
2430          }
2431        }
2432    }
2433
2434  public static class DocumentRelationshipTypeEnumFactory implements EnumFactory<DocumentRelationshipType> {
2435    public DocumentRelationshipType fromCode(String codeString) throws IllegalArgumentException {
2436      if (codeString == null || "".equals(codeString))
2437            if (codeString == null || "".equals(codeString))
2438                return null;
2439        if ("replaces".equals(codeString))
2440          return DocumentRelationshipType.REPLACES;
2441        if ("transforms".equals(codeString))
2442          return DocumentRelationshipType.TRANSFORMS;
2443        if ("signs".equals(codeString))
2444          return DocumentRelationshipType.SIGNS;
2445        if ("appends".equals(codeString))
2446          return DocumentRelationshipType.APPENDS;
2447        throw new IllegalArgumentException("Unknown DocumentRelationshipType code '"+codeString+"'");
2448        }
2449        public Enumeration<DocumentRelationshipType> fromType(Base code) throws FHIRException {
2450          if (code == null)
2451            return null;
2452          if (code.isEmpty())
2453            return new Enumeration<DocumentRelationshipType>(this);
2454          String codeString = ((PrimitiveType) code).asStringValue();
2455          if (codeString == null || "".equals(codeString))
2456            return null;
2457        if ("replaces".equals(codeString))
2458          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.REPLACES);
2459        if ("transforms".equals(codeString))
2460          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.TRANSFORMS);
2461        if ("signs".equals(codeString))
2462          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.SIGNS);
2463        if ("appends".equals(codeString))
2464          return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.APPENDS);
2465        throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'");
2466        }
2467    public String toCode(DocumentRelationshipType code) {
2468      if (code == DocumentRelationshipType.REPLACES)
2469        return "replaces";
2470      if (code == DocumentRelationshipType.TRANSFORMS)
2471        return "transforms";
2472      if (code == DocumentRelationshipType.SIGNS)
2473        return "signs";
2474      if (code == DocumentRelationshipType.APPENDS)
2475        return "appends";
2476      return "?";
2477      }
2478    public String toSystem(DocumentRelationshipType code) {
2479      return code.getSystem();
2480      }
2481    }
2482
2483    public enum EventStatus {
2484        /**
2485         * The core event has not started yet, but some staging activities have begun (e.g. surgical suite preparation).  Preparation stages may be tracked for billing purposes.
2486         */
2487        PREPARATION, 
2488        /**
2489         * The event is currently occurring.
2490         */
2491        INPROGRESS, 
2492        /**
2493         * The event was terminated prior to any activity beyond preparation.  I.e. The 'main' activity has not yet begun.  The boundary between preparatory and the 'main' activity is context-specific.
2494         */
2495        NOTDONE, 
2496        /**
2497         * The event has been temporarily stopped but is expected to resume in the future.
2498         */
2499        ONHOLD, 
2500        /**
2501         * The event was terminated prior to the full completion of the intended activity but after at least some of the 'main' activity (beyond preparation) has occurred.
2502         */
2503        STOPPED, 
2504        /**
2505         * The event has now concluded.
2506         */
2507        COMPLETED, 
2508        /**
2509         * This electronic record should never have existed, though it is possible that real-world decisions were based on it.  (If real-world activity has occurred, the status should be "stopped" rather than "entered-in-error".).
2510         */
2511        ENTEREDINERROR, 
2512        /**
2513         * The authoring/source system does not know which of the status values currently applies for this event.  Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply,  but the authoring/source system does not know which.
2514         */
2515        UNKNOWN, 
2516        /**
2517         * added to help the parsers
2518         */
2519        NULL;
2520        public static EventStatus fromCode(String codeString) throws FHIRException {
2521            if (codeString == null || "".equals(codeString))
2522                return null;
2523        if ("preparation".equals(codeString))
2524          return PREPARATION;
2525        if ("in-progress".equals(codeString))
2526          return INPROGRESS;
2527        if ("not-done".equals(codeString))
2528          return NOTDONE;
2529        if ("on-hold".equals(codeString))
2530          return ONHOLD;
2531        if ("stopped".equals(codeString))
2532          return STOPPED;
2533        if ("completed".equals(codeString))
2534          return COMPLETED;
2535        if ("entered-in-error".equals(codeString))
2536          return ENTEREDINERROR;
2537        if ("unknown".equals(codeString))
2538          return UNKNOWN;
2539        throw new FHIRException("Unknown EventStatus code '"+codeString+"'");
2540        }
2541        public String toCode() {
2542          switch (this) {
2543            case PREPARATION: return "preparation";
2544            case INPROGRESS: return "in-progress";
2545            case NOTDONE: return "not-done";
2546            case ONHOLD: return "on-hold";
2547            case STOPPED: return "stopped";
2548            case COMPLETED: return "completed";
2549            case ENTEREDINERROR: return "entered-in-error";
2550            case UNKNOWN: return "unknown";
2551            default: return "?";
2552          }
2553        }
2554        public String getSystem() {
2555          switch (this) {
2556            case PREPARATION: return "http://hl7.org/fhir/event-status";
2557            case INPROGRESS: return "http://hl7.org/fhir/event-status";
2558            case NOTDONE: return "http://hl7.org/fhir/event-status";
2559            case ONHOLD: return "http://hl7.org/fhir/event-status";
2560            case STOPPED: return "http://hl7.org/fhir/event-status";
2561            case COMPLETED: return "http://hl7.org/fhir/event-status";
2562            case ENTEREDINERROR: return "http://hl7.org/fhir/event-status";
2563            case UNKNOWN: return "http://hl7.org/fhir/event-status";
2564            default: return "?";
2565          }
2566        }
2567        public String getDefinition() {
2568          switch (this) {
2569            case PREPARATION: return "The core event has not started yet, but some staging activities have begun (e.g. surgical suite preparation).  Preparation stages may be tracked for billing purposes.";
2570            case INPROGRESS: return "The event is currently occurring.";
2571            case NOTDONE: return "The event was terminated prior to any activity beyond preparation.  I.e. The 'main' activity has not yet begun.  The boundary between preparatory and the 'main' activity is context-specific.";
2572            case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future.";
2573            case STOPPED: return "The event was terminated prior to the full completion of the intended activity but after at least some of the 'main' activity (beyond preparation) has occurred.";
2574            case COMPLETED: return "The event has now concluded.";
2575            case ENTEREDINERROR: return "This electronic record should never have existed, though it is possible that real-world decisions were based on it.  (If real-world activity has occurred, the status should be \"stopped\" rather than \"entered-in-error\".).";
2576            case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this event.  Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply,  but the authoring/source system does not know which.";
2577            default: return "?";
2578          }
2579        }
2580        public String getDisplay() {
2581          switch (this) {
2582            case PREPARATION: return "Preparation";
2583            case INPROGRESS: return "In Progress";
2584            case NOTDONE: return "Not Done";
2585            case ONHOLD: return "On Hold";
2586            case STOPPED: return "Stopped";
2587            case COMPLETED: return "Completed";
2588            case ENTEREDINERROR: return "Entered in Error";
2589            case UNKNOWN: return "Unknown";
2590            default: return "?";
2591          }
2592        }
2593    }
2594
2595  public static class EventStatusEnumFactory implements EnumFactory<EventStatus> {
2596    public EventStatus fromCode(String codeString) throws IllegalArgumentException {
2597      if (codeString == null || "".equals(codeString))
2598            if (codeString == null || "".equals(codeString))
2599                return null;
2600        if ("preparation".equals(codeString))
2601          return EventStatus.PREPARATION;
2602        if ("in-progress".equals(codeString))
2603          return EventStatus.INPROGRESS;
2604        if ("not-done".equals(codeString))
2605          return EventStatus.NOTDONE;
2606        if ("on-hold".equals(codeString))
2607          return EventStatus.ONHOLD;
2608        if ("stopped".equals(codeString))
2609          return EventStatus.STOPPED;
2610        if ("completed".equals(codeString))
2611          return EventStatus.COMPLETED;
2612        if ("entered-in-error".equals(codeString))
2613          return EventStatus.ENTEREDINERROR;
2614        if ("unknown".equals(codeString))
2615          return EventStatus.UNKNOWN;
2616        throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'");
2617        }
2618        public Enumeration<EventStatus> fromType(Base code) throws FHIRException {
2619          if (code == null)
2620            return null;
2621          if (code.isEmpty())
2622            return new Enumeration<EventStatus>(this);
2623          String codeString = ((PrimitiveType) code).asStringValue();
2624          if (codeString == null || "".equals(codeString))
2625            return null;
2626        if ("preparation".equals(codeString))
2627          return new Enumeration<EventStatus>(this, EventStatus.PREPARATION);
2628        if ("in-progress".equals(codeString))
2629          return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS);
2630        if ("not-done".equals(codeString))
2631          return new Enumeration<EventStatus>(this, EventStatus.NOTDONE);
2632        if ("on-hold".equals(codeString))
2633          return new Enumeration<EventStatus>(this, EventStatus.ONHOLD);
2634        if ("stopped".equals(codeString))
2635          return new Enumeration<EventStatus>(this, EventStatus.STOPPED);
2636        if ("completed".equals(codeString))
2637          return new Enumeration<EventStatus>(this, EventStatus.COMPLETED);
2638        if ("entered-in-error".equals(codeString))
2639          return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR);
2640        if ("unknown".equals(codeString))
2641          return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN);
2642        throw new FHIRException("Unknown EventStatus code '"+codeString+"'");
2643        }
2644    public String toCode(EventStatus code) {
2645      if (code == EventStatus.PREPARATION)
2646        return "preparation";
2647      if (code == EventStatus.INPROGRESS)
2648        return "in-progress";
2649      if (code == EventStatus.NOTDONE)
2650        return "not-done";
2651      if (code == EventStatus.ONHOLD)
2652        return "on-hold";
2653      if (code == EventStatus.STOPPED)
2654        return "stopped";
2655      if (code == EventStatus.COMPLETED)
2656        return "completed";
2657      if (code == EventStatus.ENTEREDINERROR)
2658        return "entered-in-error";
2659      if (code == EventStatus.UNKNOWN)
2660        return "unknown";
2661      return "?";
2662      }
2663    public String toSystem(EventStatus code) {
2664      return code.getSystem();
2665      }
2666    }
2667
2668    public enum FHIRAllTypes {
2669        /**
2670         * 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.
2671         */
2672        ADDRESS, 
2673        /**
2674         * A duration of time during which an organism (or a process) has existed.
2675         */
2676        AGE, 
2677        /**
2678         * A  text note which also  contains information about who made the statement and when.
2679         */
2680        ANNOTATION, 
2681        /**
2682         * For referring to data content defined in other formats.
2683         */
2684        ATTACHMENT, 
2685        /**
2686         * Base definition for all elements that are defined inside a resource - but not those in a data type.
2687         */
2688        BACKBONEELEMENT, 
2689        /**
2690         * Base definition for the few data types that are allowed to carry modifier extensions.
2691         */
2692        BACKBONETYPE, 
2693        /**
2694         * Base definition for all types defined in FHIR type system.
2695         */
2696        BASE, 
2697        /**
2698         * A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
2699         */
2700        CODEABLECONCEPT, 
2701        /**
2702         * A reference to a resource (by instance), or instead, a reference to a cencept defined in a terminology or ontology (by class).
2703         */
2704        CODEABLEREFERENCE, 
2705        /**
2706         * A reference to a code defined by a terminology system.
2707         */
2708        CODING, 
2709        /**
2710         * Specifies contact information for a person or organization.
2711         */
2712        CONTACTDETAIL, 
2713        /**
2714         * Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
2715         */
2716        CONTACTPOINT, 
2717        /**
2718         * A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
2719         */
2720        CONTRIBUTOR, 
2721        /**
2722         * 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.
2723         */
2724        COUNT, 
2725        /**
2726         * Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
2727         */
2728        DATAREQUIREMENT, 
2729        /**
2730         * The base class for all re-useable types defined as part of the FHIR Specification.
2731         */
2732        DATATYPE, 
2733        /**
2734         * A length - a value with a unit that is a physical distance.
2735         */
2736        DISTANCE, 
2737        /**
2738         * Indicates how the medication is/was taken or should be taken by the patient.
2739         */
2740        DOSAGE, 
2741        /**
2742         * A length of time.
2743         */
2744        DURATION, 
2745        /**
2746         * Base definition for all elements in a resource.
2747         */
2748        ELEMENT, 
2749        /**
2750         * Captures constraints on each element within the resource, profile, or extension.
2751         */
2752        ELEMENTDEFINITION, 
2753        /**
2754         * 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.
2755         */
2756        EXPRESSION, 
2757        /**
2758         * Optional Extension Element - found in all resources.
2759         */
2760        EXTENSION, 
2761        /**
2762         * A human's name with the ability to identify parts and usage.
2763         */
2764        HUMANNAME, 
2765        /**
2766         * An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
2767         */
2768        IDENTIFIER, 
2769        /**
2770         * 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.
2771         */
2772        MARKETINGSTATUS, 
2773        /**
2774         * 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.
2775         */
2776        META, 
2777        /**
2778         * An amount of economic utility in some recognized currency.
2779         */
2780        MONEY, 
2781        /**
2782         * null
2783         */
2784        MONEYQUANTITY, 
2785        /**
2786         * A human-readable summary of the resource conveying the essential clinical and business information for the resource.
2787         */
2788        NARRATIVE, 
2789        /**
2790         * An ordered list (distribution) of statistics.
2791         */
2792        ORDEREDDISTRIBUTION, 
2793        /**
2794         * 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.
2795         */
2796        PARAMETERDEFINITION, 
2797        /**
2798         * A time period defined by a start and end date and optionally time.
2799         */
2800        PERIOD, 
2801        /**
2802         * A populatioof people with some set of grouping criteria.
2803         */
2804        POPULATION, 
2805        /**
2806         * The base type for all re-useable types defined that have a simple property.
2807         */
2808        PRIMITIVETYPE, 
2809        /**
2810         * 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.
2811         */
2812        PRODCHARACTERISTIC, 
2813        /**
2814         * The shelf-life and storage information for a medicinal product item or container can be described using this class.
2815         */
2816        PRODUCTSHELFLIFE, 
2817        /**
2818         * 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.
2819         */
2820        QUANTITY, 
2821        /**
2822         * A set of ordered Quantities defined by a low and high limit.
2823         */
2824        RANGE, 
2825        /**
2826         * A relationship of two Quantity values - expressed as a numerator and a denominator.
2827         */
2828        RATIO, 
2829        /**
2830         * A reference from one resource to another.
2831         */
2832        REFERENCE, 
2833        /**
2834         * Related artifacts such as additional documentation, justification, or bibliographic references.
2835         */
2836        RELATEDARTIFACT, 
2837        /**
2838         * A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
2839         */
2840        SAMPLEDDATA, 
2841        /**
2842         * 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.
2843         */
2844        SIGNATURE, 
2845        /**
2846         * null
2847         */
2848        SIMPLEQUANTITY, 
2849        /**
2850         * A fact or piece of data from a  study of a large quantity of numerical data.  A mathematical or quantified characteristic of a group of observations.
2851         */
2852        STATISTIC, 
2853        /**
2854         * 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.
2855         */
2856        SUBSTANCEAMOUNT, 
2857        /**
2858         * 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.
2859         */
2860        TIMING, 
2861        /**
2862         * A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
2863         */
2864        TRIGGERDEFINITION, 
2865        /**
2866         * 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).
2867         */
2868        USAGECONTEXT, 
2869        /**
2870         * A stream of bytes
2871         */
2872        BASE64BINARY, 
2873        /**
2874         * Value of "true" or "false"
2875         */
2876        BOOLEAN, 
2877        /**
2878         * A URI that is a reference to a canonical URL on a FHIR resource
2879         */
2880        CANONICAL, 
2881        /**
2882         * 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
2883         */
2884        CODE, 
2885        /**
2886         * 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.
2887         */
2888        DATE, 
2889        /**
2890         * 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.
2891         */
2892        DATETIME, 
2893        /**
2894         * A rational number with implicit precision
2895         */
2896        DECIMAL, 
2897        /**
2898         * 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.
2899         */
2900        ID, 
2901        /**
2902         * An instant in time - known at least to the second
2903         */
2904        INSTANT, 
2905        /**
2906         * A whole number
2907         */
2908        INTEGER, 
2909        /**
2910         * A very large whole number
2911         */
2912        INTEGER64, 
2913        /**
2914         * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
2915         */
2916        MARKDOWN, 
2917        /**
2918         * An OID represented as a URI
2919         */
2920        OID, 
2921        /**
2922         * An integer with a value that is positive (e.g. >0)
2923         */
2924        POSITIVEINT, 
2925        /**
2926         * A sequence of Unicode characters
2927         */
2928        STRING, 
2929        /**
2930         * A time during the day, with no date specified
2931         */
2932        TIME, 
2933        /**
2934         * An integer with a value that is not negative (e.g. >= 0)
2935         */
2936        UNSIGNEDINT, 
2937        /**
2938         * String of characters used to identify a name or a resource
2939         */
2940        URI, 
2941        /**
2942         * A URI that is a literal reference
2943         */
2944        URL, 
2945        /**
2946         * A UUID, represented as a URI
2947         */
2948        UUID, 
2949        /**
2950         * XHTML format, as defined by W3C, but restricted usage (mainly, no active content)
2951         */
2952        XHTML, 
2953        /**
2954         * 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.
2955         */
2956        ACCOUNT, 
2957        /**
2958         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
2959         */
2960        ACTIVITYDEFINITION, 
2961        /**
2962         * A pharmaceutical product described in terms of its composition and dose form.
2963         */
2964        ADMINISTRABLEPRODUCTDEFINITION, 
2965        /**
2966         * An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject.  The unintended effects may require additional monitoring, treatment or hospitalization or may result in death.  The AdverseEvent resource also extends to potential or avoided events that could have had such effects.
2967         */
2968        ADVERSEEVENT, 
2969        /**
2970         * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.
2971         */
2972        ALLERGYINTOLERANCE, 
2973        /**
2974         * 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).
2975         */
2976        APPOINTMENT, 
2977        /**
2978         * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.
2979         */
2980        APPOINTMENTRESPONSE, 
2981        /**
2982         * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis.
2983         */
2984        AUDITEVENT, 
2985        /**
2986         * 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.
2987         */
2988        BASIC, 
2989        /**
2990         * 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.
2991         */
2992        BINARY, 
2993        /**
2994         * A material substance originating from a biological entity intended to be transplanted or infused
2995into another (possibly the same) biological entity.
2996         */
2997        BIOLOGICALLYDERIVEDPRODUCT, 
2998        /**
2999         * 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.
3000         */
3001        BODYSTRUCTURE, 
3002        /**
3003         * A container for a collection of resources.
3004         */
3005        BUNDLE, 
3006        /**
3007         * 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.
3008         */
3009        CAPABILITYSTATEMENT, 
3010        /**
3011         * 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.
3012         */
3013        CAPABILITYSTATEMENT2, 
3014        /**
3015         * 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.
3016         */
3017        CAREPLAN, 
3018        /**
3019         * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care.
3020         */
3021        CARETEAM, 
3022        /**
3023         * Catalog entries are wrappers that contextualize items included in a catalog.
3024         */
3025        CATALOGENTRY, 
3026        /**
3027         * 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.
3028         */
3029        CHARGEITEM, 
3030        /**
3031         * 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.
3032         */
3033        CHARGEITEMDEFINITION, 
3034        /**
3035         * 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.
3036         */
3037        CLAIM, 
3038        /**
3039         * This resource provides the adjudication details from the processing of a Claim resource.
3040         */
3041        CLAIMRESPONSE, 
3042        /**
3043         * 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.
3044         */
3045        CLINICALIMPRESSION, 
3046        /**
3047         * A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure.
3048         */
3049        CLINICALUSEISSUE, 
3050        /**
3051         * 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.
3052         */
3053        CODESYSTEM, 
3054        /**
3055         * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition.
3056         */
3057        COMMUNICATION, 
3058        /**
3059         * 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.
3060         */
3061        COMMUNICATIONREQUEST, 
3062        /**
3063         * A compartment definition that defines how resources are accessed on a server.
3064         */
3065        COMPARTMENTDEFINITION, 
3066        /**
3067         * 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.).
3068         */
3069        COMPOSITION, 
3070        /**
3071         * 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.
3072         */
3073        CONCEPTMAP, 
3074        /**
3075         * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.
3076         */
3077        CONDITION, 
3078        /**
3079         * A definition of a condition and information relevant to managing it.
3080         */
3081        CONDITIONDEFINITION, 
3082        /**
3083         * A record of a healthcare consumer’s  choices  or choices made on their behalf by a third party, 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.
3084         */
3085        CONSENT, 
3086        /**
3087         * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
3088         */
3089        CONTRACT, 
3090        /**
3091         * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.
3092         */
3093        COVERAGE, 
3094        /**
3095         * 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.
3096         */
3097        COVERAGEELIGIBILITYREQUEST, 
3098        /**
3099         * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.
3100         */
3101        COVERAGEELIGIBILITYRESPONSE, 
3102        /**
3103         * 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.
3104         */
3105        DETECTEDISSUE, 
3106        /**
3107         * 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.
3108         */
3109        DEVICE, 
3110        /**
3111         * The characteristics, operational status and capabilities of a medical-related component of a medical device.
3112         */
3113        DEVICEDEFINITION, 
3114        /**
3115         * Describes a measurement, calculation or setting capability of a medical device.
3116         */
3117        DEVICEMETRIC, 
3118        /**
3119         * 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.
3120         */
3121        DEVICEREQUEST, 
3122        /**
3123         * 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.
3124         */
3125        DEVICEUSESTATEMENT, 
3126        /**
3127         * 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.
3128         */
3129        DIAGNOSTICREPORT, 
3130        /**
3131         * A collection of documents compiled for a purpose together with metadata that applies to the collection.
3132         */
3133        DOCUMENTMANIFEST, 
3134        /**
3135         * A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this "document" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare.  The DocumentReference resource provides metadata about the document so that the document can be discovered and managed.  The actual content may be inline base64 encoded data or provided by direct reference.
3136         */
3137        DOCUMENTREFERENCE, 
3138        /**
3139         * A resource that includes narrative, extensions, and contained resources.
3140         */
3141        DOMAINRESOURCE, 
3142        /**
3143         * 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.
3144         */
3145        ENCOUNTER, 
3146        /**
3147         * 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.
3148         */
3149        ENDPOINT, 
3150        /**
3151         * This resource provides the insurance enrollment details to the insurer regarding a specified coverage.
3152         */
3153        ENROLLMENTREQUEST, 
3154        /**
3155         * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.
3156         */
3157        ENROLLMENTRESPONSE, 
3158        /**
3159         * 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.
3160         */
3161        EPISODEOFCARE, 
3162        /**
3163         * The EventDefinition resource provides a reusable description of when a particular event can occur.
3164         */
3165        EVENTDEFINITION, 
3166        /**
3167         * This represents statistics, certainty, both the intended and actual population, and evidence variables.
3168         */
3169        EVIDENCE, 
3170        /**
3171         * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
3172         */
3173        EVIDENCEVARIABLE, 
3174        /**
3175         * Example of workflow instance.
3176         */
3177        EXAMPLESCENARIO, 
3178        /**
3179         * 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.
3180         */
3181        EXPLANATIONOFBENEFIT, 
3182        /**
3183         * Significant health conditions for a person related to the patient relevant in the context of care for the patient.
3184         */
3185        FAMILYMEMBERHISTORY, 
3186        /**
3187         * Prospective warnings of potential issues when providing care to the patient.
3188         */
3189        FLAG, 
3190        /**
3191         * 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.
3192         */
3193        GOAL, 
3194        /**
3195         * 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.
3196         */
3197        GRAPHDEFINITION, 
3198        /**
3199         * 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.
3200         */
3201        GROUP, 
3202        /**
3203         * 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.
3204         */
3205        GUIDANCERESPONSE, 
3206        /**
3207         * The details of a healthcare service available at a location.
3208         */
3209        HEALTHCARESERVICE, 
3210        /**
3211         * 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.
3212         */
3213        IMAGINGSTUDY, 
3214        /**
3215         * 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.
3216         */
3217        IMMUNIZATION, 
3218        /**
3219         * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations.
3220         */
3221        IMMUNIZATIONEVALUATION, 
3222        /**
3223         * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.
3224         */
3225        IMMUNIZATIONRECOMMENDATION, 
3226        /**
3227         * 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.
3228         */
3229        IMPLEMENTATIONGUIDE, 
3230        /**
3231         * An ingredient of a manufactured item or pharmaceutical product.
3232         */
3233        INGREDIENT, 
3234        /**
3235         * Details of a Health Insurance product/plan provided by an organization.
3236         */
3237        INSURANCEPLAN, 
3238        /**
3239         * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.
3240         */
3241        INVOICE, 
3242        /**
3243         * 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.
3244         */
3245        LIBRARY, 
3246        /**
3247         * Identifies two or more records (resource instances) that refer to the same real-world "occurrence".
3248         */
3249        LINKAGE, 
3250        /**
3251         * A list is a curated collection of resources.
3252         */
3253        LIST, 
3254        /**
3255         * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.
3256         */
3257        LOCATION, 
3258        /**
3259         * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product.
3260         */
3261        MANUFACTUREDITEMDEFINITION, 
3262        /**
3263         * The Measure resource provides the definition of a quality measure.
3264         */
3265        MEASURE, 
3266        /**
3267         * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.
3268         */
3269        MEASUREREPORT, 
3270        /**
3271         * 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.
3272         */
3273        MEDICATION, 
3274        /**
3275         * 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.
3276         */
3277        MEDICATIONADMINISTRATION, 
3278        /**
3279         * 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.
3280         */
3281        MEDICATIONDISPENSE, 
3282        /**
3283         * Information about a medication that is used to support knowledge.
3284         */
3285        MEDICATIONKNOWLEDGE, 
3286        /**
3287         * 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.
3288         */
3289        MEDICATIONREQUEST, 
3290        /**
3291         * A record of a medication that is being consumed by a patient.   A MedicationUsage 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. 
3292
3293The primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medicationusage 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 Usage 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.
3294         */
3295        MEDICATIONUSAGE, 
3296        /**
3297         * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).
3298         */
3299        MEDICINALPRODUCTDEFINITION, 
3300        /**
3301         * 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.
3302         */
3303        MESSAGEDEFINITION, 
3304        /**
3305         * 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.
3306         */
3307        MESSAGEHEADER, 
3308        /**
3309         * Raw data describing a biological sequence.
3310         */
3311        MOLECULARSEQUENCE, 
3312        /**
3313         * 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.
3314         */
3315        NAMINGSYSTEM, 
3316        /**
3317         * A record of food or fluid that is being consumed by a patient.   A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past.  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 or through an app that tracks food or fluids consumed.   The consumption information may come from sources such as the patient's memory, from a nutrition label,  or from a clinician documenting observed intake.
3318         */
3319        NUTRITIONINTAKE, 
3320        /**
3321         * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.
3322         */
3323        NUTRITIONORDER, 
3324        /**
3325         * Measurements and simple assertions made about a patient, device or other subject.
3326         */
3327        OBSERVATION, 
3328        /**
3329         * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.
3330         */
3331        OBSERVATIONDEFINITION, 
3332        /**
3333         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
3334         */
3335        OPERATIONDEFINITION, 
3336        /**
3337         * A collection of error, warning, or information messages that result from a system action.
3338         */
3339        OPERATIONOUTCOME, 
3340        /**
3341         * 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.
3342         */
3343        ORGANIZATION, 
3344        /**
3345         * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.
3346         */
3347        ORGANIZATIONAFFILIATION, 
3348        /**
3349         * A medicinal product in a container or package.
3350         */
3351        PACKAGEDPRODUCTDEFINITION, 
3352        /**
3353         * 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.
3354         */
3355        PARAMETERS, 
3356        /**
3357         * Demographics and other administrative information about an individual or animal receiving care or other health-related services.
3358         */
3359        PATIENT, 
3360        /**
3361         * This resource provides the status of the payment for goods and services rendered, and the request and response resource references.
3362         */
3363        PAYMENTNOTICE, 
3364        /**
3365         * This resource provides the details including amount of a payment and allocates the payment items being paid.
3366         */
3367        PAYMENTRECONCILIATION, 
3368        /**
3369         * Demographics and administrative information about a person independent of a specific health-related context.
3370         */
3371        PERSON, 
3372        /**
3373         * 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.
3374         */
3375        PLANDEFINITION, 
3376        /**
3377         * A person who is directly or indirectly involved in the provisioning of healthcare.
3378         */
3379        PRACTITIONER, 
3380        /**
3381         * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.
3382         */
3383        PRACTITIONERROLE, 
3384        /**
3385         * 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.
3386         */
3387        PROCEDURE, 
3388        /**
3389         * 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.
3390         */
3391        PROVENANCE, 
3392        /**
3393         * 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.
3394         */
3395        QUESTIONNAIRE, 
3396        /**
3397         * 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.
3398         */
3399        QUESTIONNAIRERESPONSE, 
3400        /**
3401         * The regulatory authorization of a medicinal product.
3402         */
3403        REGULATEDAUTHORIZATION, 
3404        /**
3405         * 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.
3406         */
3407        RELATEDPERSON, 
3408        /**
3409         * 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".
3410         */
3411        REQUESTGROUP, 
3412        /**
3413         * 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.
3414         */
3415        RESEARCHSTUDY, 
3416        /**
3417         * A physical entity which is the primary unit of operational and/or administrative interest in a study.
3418         */
3419        RESEARCHSUBJECT, 
3420        /**
3421         * This is the base resource type for everything.
3422         */
3423        RESOURCE, 
3424        /**
3425         * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.
3426         */
3427        RISKASSESSMENT, 
3428        /**
3429         * A container for slots of time that may be available for booking appointments.
3430         */
3431        SCHEDULE, 
3432        /**
3433         * A search parameter that defines a named search item that can be used to search/filter on a resource.
3434         */
3435        SEARCHPARAMETER, 
3436        /**
3437         * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.
3438         */
3439        SERVICEREQUEST, 
3440        /**
3441         * A slot of time on a schedule that may be available for booking appointments.
3442         */
3443        SLOT, 
3444        /**
3445         * A sample to be used for analysis.
3446         */
3447        SPECIMEN, 
3448        /**
3449         * A kind of specimen with associated set of requirements.
3450         */
3451        SPECIMENDEFINITION, 
3452        /**
3453         * 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.
3454         */
3455        STRUCTUREDEFINITION, 
3456        /**
3457         * A Map of relationships between 2 structures that can be used to transform data.
3458         */
3459        STRUCTUREMAP, 
3460        /**
3461         * The subscription resource describes a particular client's request to be notified about a Topic.
3462         */
3463        SUBSCRIPTION, 
3464        /**
3465         * A homogeneous material with a definite composition.
3466         */
3467        SUBSTANCE, 
3468        /**
3469         * The detailed description of a substance, typically at a level beyond what is used for prescribing.
3470         */
3471        SUBSTANCEDEFINITION, 
3472        /**
3473         * 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.
3474         */
3475        SUBSTANCENUCLEICACID, 
3476        /**
3477         * Todo.
3478         */
3479        SUBSTANCEPOLYMER, 
3480        /**
3481         * 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.
3482         */
3483        SUBSTANCEPROTEIN, 
3484        /**
3485         * Todo.
3486         */
3487        SUBSTANCEREFERENCEINFORMATION, 
3488        /**
3489         * 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.
3490         */
3491        SUBSTANCESOURCEMATERIAL, 
3492        /**
3493         * Record of delivery of what is supplied.
3494         */
3495        SUPPLYDELIVERY, 
3496        /**
3497         * A record of a request for a medication, substance or device used in the healthcare setting.
3498         */
3499        SUPPLYREQUEST, 
3500        /**
3501         * A task to be performed.
3502         */
3503        TASK, 
3504        /**
3505         * A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
3506         */
3507        TERMINOLOGYCAPABILITIES, 
3508        /**
3509         * A summary of information based on the results of executing a TestScript.
3510         */
3511        TESTREPORT, 
3512        /**
3513         * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
3514         */
3515        TESTSCRIPT, 
3516        /**
3517         * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic.
3518         */
3519        TOPIC, 
3520        /**
3521         * 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).
3522         */
3523        VALUESET, 
3524        /**
3525         * Describes validation requirements, source(s), status and dates for one or more elements.
3526         */
3527        VERIFICATIONRESULT, 
3528        /**
3529         * An authorization for the provision of glasses and/or contact lenses to a patient.
3530         */
3531        VISIONPRESCRIPTION, 
3532        /**
3533         * A place holder that means any kind of data type
3534         */
3535        TYPE, 
3536        /**
3537         * A place holder that means any kind of resource
3538         */
3539        ANY, 
3540        /**
3541         * added to help the parsers
3542         */
3543        NULL;
3544        public static FHIRAllTypes fromCode(String codeString) throws FHIRException {
3545            if (codeString == null || "".equals(codeString))
3546                return null;
3547        if ("Address".equals(codeString))
3548          return ADDRESS;
3549        if ("Age".equals(codeString))
3550          return AGE;
3551        if ("Annotation".equals(codeString))
3552          return ANNOTATION;
3553        if ("Attachment".equals(codeString))
3554          return ATTACHMENT;
3555        if ("BackboneElement".equals(codeString))
3556          return BACKBONEELEMENT;
3557        if ("BackboneType".equals(codeString))
3558          return BACKBONETYPE;
3559        if ("Base".equals(codeString))
3560          return BASE;
3561        if ("CodeableConcept".equals(codeString))
3562          return CODEABLECONCEPT;
3563        if ("CodeableReference".equals(codeString))
3564          return CODEABLEREFERENCE;
3565        if ("Coding".equals(codeString))
3566          return CODING;
3567        if ("ContactDetail".equals(codeString))
3568          return CONTACTDETAIL;
3569        if ("ContactPoint".equals(codeString))
3570          return CONTACTPOINT;
3571        if ("Contributor".equals(codeString))
3572          return CONTRIBUTOR;
3573        if ("Count".equals(codeString))
3574          return COUNT;
3575        if ("DataRequirement".equals(codeString))
3576          return DATAREQUIREMENT;
3577        if ("DataType".equals(codeString))
3578          return DATATYPE;
3579        if ("Distance".equals(codeString))
3580          return DISTANCE;
3581        if ("Dosage".equals(codeString))
3582          return DOSAGE;
3583        if ("Duration".equals(codeString))
3584          return DURATION;
3585        if ("Element".equals(codeString))
3586          return ELEMENT;
3587        if ("ElementDefinition".equals(codeString))
3588          return ELEMENTDEFINITION;
3589        if ("Expression".equals(codeString))
3590          return EXPRESSION;
3591        if ("Extension".equals(codeString))
3592          return EXTENSION;
3593        if ("HumanName".equals(codeString))
3594          return HUMANNAME;
3595        if ("Identifier".equals(codeString))
3596          return IDENTIFIER;
3597        if ("MarketingStatus".equals(codeString))
3598          return MARKETINGSTATUS;
3599        if ("Meta".equals(codeString))
3600          return META;
3601        if ("Money".equals(codeString))
3602          return MONEY;
3603        if ("MoneyQuantity".equals(codeString))
3604          return MONEYQUANTITY;
3605        if ("Narrative".equals(codeString))
3606          return NARRATIVE;
3607        if ("OrderedDistribution".equals(codeString))
3608          return ORDEREDDISTRIBUTION;
3609        if ("ParameterDefinition".equals(codeString))
3610          return PARAMETERDEFINITION;
3611        if ("Period".equals(codeString))
3612          return PERIOD;
3613        if ("Population".equals(codeString))
3614          return POPULATION;
3615        if ("PrimitiveType".equals(codeString))
3616          return PRIMITIVETYPE;
3617        if ("ProdCharacteristic".equals(codeString))
3618          return PRODCHARACTERISTIC;
3619        if ("ProductShelfLife".equals(codeString))
3620          return PRODUCTSHELFLIFE;
3621        if ("Quantity".equals(codeString))
3622          return QUANTITY;
3623        if ("Range".equals(codeString))
3624          return RANGE;
3625        if ("Ratio".equals(codeString))
3626          return RATIO;
3627        if ("Reference".equals(codeString))
3628          return REFERENCE;
3629        if ("RelatedArtifact".equals(codeString))
3630          return RELATEDARTIFACT;
3631        if ("SampledData".equals(codeString))
3632          return SAMPLEDDATA;
3633        if ("Signature".equals(codeString))
3634          return SIGNATURE;
3635        if ("SimpleQuantity".equals(codeString))
3636          return SIMPLEQUANTITY;
3637        if ("Statistic".equals(codeString))
3638          return STATISTIC;
3639        if ("SubstanceAmount".equals(codeString))
3640          return SUBSTANCEAMOUNT;
3641        if ("Timing".equals(codeString))
3642          return TIMING;
3643        if ("TriggerDefinition".equals(codeString))
3644          return TRIGGERDEFINITION;
3645        if ("UsageContext".equals(codeString))
3646          return USAGECONTEXT;
3647        if ("base64Binary".equals(codeString))
3648          return BASE64BINARY;
3649        if ("boolean".equals(codeString))
3650          return BOOLEAN;
3651        if ("canonical".equals(codeString))
3652          return CANONICAL;
3653        if ("code".equals(codeString))
3654          return CODE;
3655        if ("date".equals(codeString))
3656          return DATE;
3657        if ("dateTime".equals(codeString))
3658          return DATETIME;
3659        if ("decimal".equals(codeString))
3660          return DECIMAL;
3661        if ("id".equals(codeString))
3662          return ID;
3663        if ("instant".equals(codeString))
3664          return INSTANT;
3665        if ("integer".equals(codeString))
3666          return INTEGER;
3667        if ("integer64".equals(codeString))
3668          return INTEGER64;
3669        if ("markdown".equals(codeString))
3670          return MARKDOWN;
3671        if ("oid".equals(codeString))
3672          return OID;
3673        if ("positiveInt".equals(codeString))
3674          return POSITIVEINT;
3675        if ("string".equals(codeString))
3676          return STRING;
3677        if ("time".equals(codeString))
3678          return TIME;
3679        if ("unsignedInt".equals(codeString))
3680          return UNSIGNEDINT;
3681        if ("uri".equals(codeString))
3682          return URI;
3683        if ("url".equals(codeString))
3684          return URL;
3685        if ("uuid".equals(codeString))
3686          return UUID;
3687        if ("xhtml".equals(codeString))
3688          return XHTML;
3689        if ("Account".equals(codeString))
3690          return ACCOUNT;
3691        if ("ActivityDefinition".equals(codeString))
3692          return ACTIVITYDEFINITION;
3693        if ("AdministrableProductDefinition".equals(codeString))
3694          return ADMINISTRABLEPRODUCTDEFINITION;
3695        if ("AdverseEvent".equals(codeString))
3696          return ADVERSEEVENT;
3697        if ("AllergyIntolerance".equals(codeString))
3698          return ALLERGYINTOLERANCE;
3699        if ("Appointment".equals(codeString))
3700          return APPOINTMENT;
3701        if ("AppointmentResponse".equals(codeString))
3702          return APPOINTMENTRESPONSE;
3703        if ("AuditEvent".equals(codeString))
3704          return AUDITEVENT;
3705        if ("Basic".equals(codeString))
3706          return BASIC;
3707        if ("Binary".equals(codeString))
3708          return BINARY;
3709        if ("BiologicallyDerivedProduct".equals(codeString))
3710          return BIOLOGICALLYDERIVEDPRODUCT;
3711        if ("BodyStructure".equals(codeString))
3712          return BODYSTRUCTURE;
3713        if ("Bundle".equals(codeString))
3714          return BUNDLE;
3715        if ("CapabilityStatement".equals(codeString))
3716          return CAPABILITYSTATEMENT;
3717        if ("CapabilityStatement2".equals(codeString))
3718          return CAPABILITYSTATEMENT2;
3719        if ("CarePlan".equals(codeString))
3720          return CAREPLAN;
3721        if ("CareTeam".equals(codeString))
3722          return CARETEAM;
3723        if ("CatalogEntry".equals(codeString))
3724          return CATALOGENTRY;
3725        if ("ChargeItem".equals(codeString))
3726          return CHARGEITEM;
3727        if ("ChargeItemDefinition".equals(codeString))
3728          return CHARGEITEMDEFINITION;
3729        if ("Claim".equals(codeString))
3730          return CLAIM;
3731        if ("ClaimResponse".equals(codeString))
3732          return CLAIMRESPONSE;
3733        if ("ClinicalImpression".equals(codeString))
3734          return CLINICALIMPRESSION;
3735        if ("ClinicalUseIssue".equals(codeString))
3736          return CLINICALUSEISSUE;
3737        if ("CodeSystem".equals(codeString))
3738          return CODESYSTEM;
3739        if ("Communication".equals(codeString))
3740          return COMMUNICATION;
3741        if ("CommunicationRequest".equals(codeString))
3742          return COMMUNICATIONREQUEST;
3743        if ("CompartmentDefinition".equals(codeString))
3744          return COMPARTMENTDEFINITION;
3745        if ("Composition".equals(codeString))
3746          return COMPOSITION;
3747        if ("ConceptMap".equals(codeString))
3748          return CONCEPTMAP;
3749        if ("Condition".equals(codeString))
3750          return CONDITION;
3751        if ("ConditionDefinition".equals(codeString))
3752          return CONDITIONDEFINITION;
3753        if ("Consent".equals(codeString))
3754          return CONSENT;
3755        if ("Contract".equals(codeString))
3756          return CONTRACT;
3757        if ("Coverage".equals(codeString))
3758          return COVERAGE;
3759        if ("CoverageEligibilityRequest".equals(codeString))
3760          return COVERAGEELIGIBILITYREQUEST;
3761        if ("CoverageEligibilityResponse".equals(codeString))
3762          return COVERAGEELIGIBILITYRESPONSE;
3763        if ("DetectedIssue".equals(codeString))
3764          return DETECTEDISSUE;
3765        if ("Device".equals(codeString))
3766          return DEVICE;
3767        if ("DeviceDefinition".equals(codeString))
3768          return DEVICEDEFINITION;
3769        if ("DeviceMetric".equals(codeString))
3770          return DEVICEMETRIC;
3771        if ("DeviceRequest".equals(codeString))
3772          return DEVICEREQUEST;
3773        if ("DeviceUseStatement".equals(codeString))
3774          return DEVICEUSESTATEMENT;
3775        if ("DiagnosticReport".equals(codeString))
3776          return DIAGNOSTICREPORT;
3777        if ("DocumentManifest".equals(codeString))
3778          return DOCUMENTMANIFEST;
3779        if ("DocumentReference".equals(codeString))
3780          return DOCUMENTREFERENCE;
3781        if ("DomainResource".equals(codeString))
3782          return DOMAINRESOURCE;
3783        if ("Encounter".equals(codeString))
3784          return ENCOUNTER;
3785        if ("Endpoint".equals(codeString))
3786          return ENDPOINT;
3787        if ("EnrollmentRequest".equals(codeString))
3788          return ENROLLMENTREQUEST;
3789        if ("EnrollmentResponse".equals(codeString))
3790          return ENROLLMENTRESPONSE;
3791        if ("EpisodeOfCare".equals(codeString))
3792          return EPISODEOFCARE;
3793        if ("EventDefinition".equals(codeString))
3794          return EVENTDEFINITION;
3795        if ("Evidence".equals(codeString))
3796          return EVIDENCE;
3797        if ("EvidenceVariable".equals(codeString))
3798          return EVIDENCEVARIABLE;
3799        if ("ExampleScenario".equals(codeString))
3800          return EXAMPLESCENARIO;
3801        if ("ExplanationOfBenefit".equals(codeString))
3802          return EXPLANATIONOFBENEFIT;
3803        if ("FamilyMemberHistory".equals(codeString))
3804          return FAMILYMEMBERHISTORY;
3805        if ("Flag".equals(codeString))
3806          return FLAG;
3807        if ("Goal".equals(codeString))
3808          return GOAL;
3809        if ("GraphDefinition".equals(codeString))
3810          return GRAPHDEFINITION;
3811        if ("Group".equals(codeString))
3812          return GROUP;
3813        if ("GuidanceResponse".equals(codeString))
3814          return GUIDANCERESPONSE;
3815        if ("HealthcareService".equals(codeString))
3816          return HEALTHCARESERVICE;
3817        if ("ImagingStudy".equals(codeString))
3818          return IMAGINGSTUDY;
3819        if ("Immunization".equals(codeString))
3820          return IMMUNIZATION;
3821        if ("ImmunizationEvaluation".equals(codeString))
3822          return IMMUNIZATIONEVALUATION;
3823        if ("ImmunizationRecommendation".equals(codeString))
3824          return IMMUNIZATIONRECOMMENDATION;
3825        if ("ImplementationGuide".equals(codeString))
3826          return IMPLEMENTATIONGUIDE;
3827        if ("Ingredient".equals(codeString))
3828          return INGREDIENT;
3829        if ("InsurancePlan".equals(codeString))
3830          return INSURANCEPLAN;
3831        if ("Invoice".equals(codeString))
3832          return INVOICE;
3833        if ("Library".equals(codeString))
3834          return LIBRARY;
3835        if ("Linkage".equals(codeString))
3836          return LINKAGE;
3837        if ("List".equals(codeString))
3838          return LIST;
3839        if ("Location".equals(codeString))
3840          return LOCATION;
3841        if ("ManufacturedItemDefinition".equals(codeString))
3842          return MANUFACTUREDITEMDEFINITION;
3843        if ("Measure".equals(codeString))
3844          return MEASURE;
3845        if ("MeasureReport".equals(codeString))
3846          return MEASUREREPORT;
3847        if ("Medication".equals(codeString))
3848          return MEDICATION;
3849        if ("MedicationAdministration".equals(codeString))
3850          return MEDICATIONADMINISTRATION;
3851        if ("MedicationDispense".equals(codeString))
3852          return MEDICATIONDISPENSE;
3853        if ("MedicationKnowledge".equals(codeString))
3854          return MEDICATIONKNOWLEDGE;
3855        if ("MedicationRequest".equals(codeString))
3856          return MEDICATIONREQUEST;
3857        if ("MedicationUsage".equals(codeString))
3858          return MEDICATIONUSAGE;
3859        if ("MedicinalProductDefinition".equals(codeString))
3860          return MEDICINALPRODUCTDEFINITION;
3861        if ("MessageDefinition".equals(codeString))
3862          return MESSAGEDEFINITION;
3863        if ("MessageHeader".equals(codeString))
3864          return MESSAGEHEADER;
3865        if ("MolecularSequence".equals(codeString))
3866          return MOLECULARSEQUENCE;
3867        if ("NamingSystem".equals(codeString))
3868          return NAMINGSYSTEM;
3869        if ("NutritionIntake".equals(codeString))
3870          return NUTRITIONINTAKE;
3871        if ("NutritionOrder".equals(codeString))
3872          return NUTRITIONORDER;
3873        if ("Observation".equals(codeString))
3874          return OBSERVATION;
3875        if ("ObservationDefinition".equals(codeString))
3876          return OBSERVATIONDEFINITION;
3877        if ("OperationDefinition".equals(codeString))
3878          return OPERATIONDEFINITION;
3879        if ("OperationOutcome".equals(codeString))
3880          return OPERATIONOUTCOME;
3881        if ("Organization".equals(codeString))
3882          return ORGANIZATION;
3883        if ("OrganizationAffiliation".equals(codeString))
3884          return ORGANIZATIONAFFILIATION;
3885        if ("PackagedProductDefinition".equals(codeString))
3886          return PACKAGEDPRODUCTDEFINITION;
3887        if ("Parameters".equals(codeString))
3888          return PARAMETERS;
3889        if ("Patient".equals(codeString))
3890          return PATIENT;
3891        if ("PaymentNotice".equals(codeString))
3892          return PAYMENTNOTICE;
3893        if ("PaymentReconciliation".equals(codeString))
3894          return PAYMENTRECONCILIATION;
3895        if ("Person".equals(codeString))
3896          return PERSON;
3897        if ("PlanDefinition".equals(codeString))
3898          return PLANDEFINITION;
3899        if ("Practitioner".equals(codeString))
3900          return PRACTITIONER;
3901        if ("PractitionerRole".equals(codeString))
3902          return PRACTITIONERROLE;
3903        if ("Procedure".equals(codeString))
3904          return PROCEDURE;
3905        if ("Provenance".equals(codeString))
3906          return PROVENANCE;
3907        if ("Questionnaire".equals(codeString))
3908          return QUESTIONNAIRE;
3909        if ("QuestionnaireResponse".equals(codeString))
3910          return QUESTIONNAIRERESPONSE;
3911        if ("RegulatedAuthorization".equals(codeString))
3912          return REGULATEDAUTHORIZATION;
3913        if ("RelatedPerson".equals(codeString))
3914          return RELATEDPERSON;
3915        if ("RequestGroup".equals(codeString))
3916          return REQUESTGROUP;
3917        if ("ResearchStudy".equals(codeString))
3918          return RESEARCHSTUDY;
3919        if ("ResearchSubject".equals(codeString))
3920          return RESEARCHSUBJECT;
3921        if ("Resource".equals(codeString))
3922          return RESOURCE;
3923        if ("RiskAssessment".equals(codeString))
3924          return RISKASSESSMENT;
3925        if ("Schedule".equals(codeString))
3926          return SCHEDULE;
3927        if ("SearchParameter".equals(codeString))
3928          return SEARCHPARAMETER;
3929        if ("ServiceRequest".equals(codeString))
3930          return SERVICEREQUEST;
3931        if ("Slot".equals(codeString))
3932          return SLOT;
3933        if ("Specimen".equals(codeString))
3934          return SPECIMEN;
3935        if ("SpecimenDefinition".equals(codeString))
3936          return SPECIMENDEFINITION;
3937        if ("StructureDefinition".equals(codeString))
3938          return STRUCTUREDEFINITION;
3939        if ("StructureMap".equals(codeString))
3940          return STRUCTUREMAP;
3941        if ("Subscription".equals(codeString))
3942          return SUBSCRIPTION;
3943        if ("Substance".equals(codeString))
3944          return SUBSTANCE;
3945        if ("SubstanceDefinition".equals(codeString))
3946          return SUBSTANCEDEFINITION;
3947        if ("SubstanceNucleicAcid".equals(codeString))
3948          return SUBSTANCENUCLEICACID;
3949        if ("SubstancePolymer".equals(codeString))
3950          return SUBSTANCEPOLYMER;
3951        if ("SubstanceProtein".equals(codeString))
3952          return SUBSTANCEPROTEIN;
3953        if ("SubstanceReferenceInformation".equals(codeString))
3954          return SUBSTANCEREFERENCEINFORMATION;
3955        if ("SubstanceSourceMaterial".equals(codeString))
3956          return SUBSTANCESOURCEMATERIAL;
3957        if ("SupplyDelivery".equals(codeString))
3958          return SUPPLYDELIVERY;
3959        if ("SupplyRequest".equals(codeString))
3960          return SUPPLYREQUEST;
3961        if ("Task".equals(codeString))
3962          return TASK;
3963        if ("TerminologyCapabilities".equals(codeString))
3964          return TERMINOLOGYCAPABILITIES;
3965        if ("TestReport".equals(codeString))
3966          return TESTREPORT;
3967        if ("TestScript".equals(codeString))
3968          return TESTSCRIPT;
3969        if ("Topic".equals(codeString))
3970          return TOPIC;
3971        if ("ValueSet".equals(codeString))
3972          return VALUESET;
3973        if ("VerificationResult".equals(codeString))
3974          return VERIFICATIONRESULT;
3975        if ("VisionPrescription".equals(codeString))
3976          return VISIONPRESCRIPTION;
3977        if ("Type".equals(codeString))
3978          return TYPE;
3979        if ("Any".equals(codeString))
3980          return ANY;
3981        throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'");
3982        }
3983        public String toCode() {
3984          switch (this) {
3985            case ADDRESS: return "Address";
3986            case AGE: return "Age";
3987            case ANNOTATION: return "Annotation";
3988            case ATTACHMENT: return "Attachment";
3989            case BACKBONEELEMENT: return "BackboneElement";
3990            case BACKBONETYPE: return "BackboneType";
3991            case BASE: return "Base";
3992            case CODEABLECONCEPT: return "CodeableConcept";
3993            case CODEABLEREFERENCE: return "CodeableReference";
3994            case CODING: return "Coding";
3995            case CONTACTDETAIL: return "ContactDetail";
3996            case CONTACTPOINT: return "ContactPoint";
3997            case CONTRIBUTOR: return "Contributor";
3998            case COUNT: return "Count";
3999            case DATAREQUIREMENT: return "DataRequirement";
4000            case DATATYPE: return "DataType";
4001            case DISTANCE: return "Distance";
4002            case DOSAGE: return "Dosage";
4003            case DURATION: return "Duration";
4004            case ELEMENT: return "Element";
4005            case ELEMENTDEFINITION: return "ElementDefinition";
4006            case EXPRESSION: return "Expression";
4007            case EXTENSION: return "Extension";
4008            case HUMANNAME: return "HumanName";
4009            case IDENTIFIER: return "Identifier";
4010            case MARKETINGSTATUS: return "MarketingStatus";
4011            case META: return "Meta";
4012            case MONEY: return "Money";
4013            case MONEYQUANTITY: return "MoneyQuantity";
4014            case NARRATIVE: return "Narrative";
4015            case ORDEREDDISTRIBUTION: return "OrderedDistribution";
4016            case PARAMETERDEFINITION: return "ParameterDefinition";
4017            case PERIOD: return "Period";
4018            case POPULATION: return "Population";
4019            case PRIMITIVETYPE: return "PrimitiveType";
4020            case PRODCHARACTERISTIC: return "ProdCharacteristic";
4021            case PRODUCTSHELFLIFE: return "ProductShelfLife";
4022            case QUANTITY: return "Quantity";
4023            case RANGE: return "Range";
4024            case RATIO: return "Ratio";
4025            case REFERENCE: return "Reference";
4026            case RELATEDARTIFACT: return "RelatedArtifact";
4027            case SAMPLEDDATA: return "SampledData";
4028            case SIGNATURE: return "Signature";
4029            case SIMPLEQUANTITY: return "SimpleQuantity";
4030            case STATISTIC: return "Statistic";
4031            case SUBSTANCEAMOUNT: return "SubstanceAmount";
4032            case TIMING: return "Timing";
4033            case TRIGGERDEFINITION: return "TriggerDefinition";
4034            case USAGECONTEXT: return "UsageContext";
4035            case BASE64BINARY: return "base64Binary";
4036            case BOOLEAN: return "boolean";
4037            case CANONICAL: return "canonical";
4038            case CODE: return "code";
4039            case DATE: return "date";
4040            case DATETIME: return "dateTime";
4041            case DECIMAL: return "decimal";
4042            case ID: return "id";
4043            case INSTANT: return "instant";
4044            case INTEGER: return "integer";
4045            case INTEGER64: return "integer64";
4046            case MARKDOWN: return "markdown";
4047            case OID: return "oid";
4048            case POSITIVEINT: return "positiveInt";
4049            case STRING: return "string";
4050            case TIME: return "time";
4051            case UNSIGNEDINT: return "unsignedInt";
4052            case URI: return "uri";
4053            case URL: return "url";
4054            case UUID: return "uuid";
4055            case XHTML: return "xhtml";
4056            case ACCOUNT: return "Account";
4057            case ACTIVITYDEFINITION: return "ActivityDefinition";
4058            case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition";
4059            case ADVERSEEVENT: return "AdverseEvent";
4060            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
4061            case APPOINTMENT: return "Appointment";
4062            case APPOINTMENTRESPONSE: return "AppointmentResponse";
4063            case AUDITEVENT: return "AuditEvent";
4064            case BASIC: return "Basic";
4065            case BINARY: return "Binary";
4066            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
4067            case BODYSTRUCTURE: return "BodyStructure";
4068            case BUNDLE: return "Bundle";
4069            case CAPABILITYSTATEMENT: return "CapabilityStatement";
4070            case CAPABILITYSTATEMENT2: return "CapabilityStatement2";
4071            case CAREPLAN: return "CarePlan";
4072            case CARETEAM: return "CareTeam";
4073            case CATALOGENTRY: return "CatalogEntry";
4074            case CHARGEITEM: return "ChargeItem";
4075            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
4076            case CLAIM: return "Claim";
4077            case CLAIMRESPONSE: return "ClaimResponse";
4078            case CLINICALIMPRESSION: return "ClinicalImpression";
4079            case CLINICALUSEISSUE: return "ClinicalUseIssue";
4080            case CODESYSTEM: return "CodeSystem";
4081            case COMMUNICATION: return "Communication";
4082            case COMMUNICATIONREQUEST: return "CommunicationRequest";
4083            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
4084            case COMPOSITION: return "Composition";
4085            case CONCEPTMAP: return "ConceptMap";
4086            case CONDITION: return "Condition";
4087            case CONDITIONDEFINITION: return "ConditionDefinition";
4088            case CONSENT: return "Consent";
4089            case CONTRACT: return "Contract";
4090            case COVERAGE: return "Coverage";
4091            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
4092            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
4093            case DETECTEDISSUE: return "DetectedIssue";
4094            case DEVICE: return "Device";
4095            case DEVICEDEFINITION: return "DeviceDefinition";
4096            case DEVICEMETRIC: return "DeviceMetric";
4097            case DEVICEREQUEST: return "DeviceRequest";
4098            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
4099            case DIAGNOSTICREPORT: return "DiagnosticReport";
4100            case DOCUMENTMANIFEST: return "DocumentManifest";
4101            case DOCUMENTREFERENCE: return "DocumentReference";
4102            case DOMAINRESOURCE: return "DomainResource";
4103            case ENCOUNTER: return "Encounter";
4104            case ENDPOINT: return "Endpoint";
4105            case ENROLLMENTREQUEST: return "EnrollmentRequest";
4106            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
4107            case EPISODEOFCARE: return "EpisodeOfCare";
4108            case EVENTDEFINITION: return "EventDefinition";
4109            case EVIDENCE: return "Evidence";
4110            case EVIDENCEVARIABLE: return "EvidenceVariable";
4111            case EXAMPLESCENARIO: return "ExampleScenario";
4112            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
4113            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
4114            case FLAG: return "Flag";
4115            case GOAL: return "Goal";
4116            case GRAPHDEFINITION: return "GraphDefinition";
4117            case GROUP: return "Group";
4118            case GUIDANCERESPONSE: return "GuidanceResponse";
4119            case HEALTHCARESERVICE: return "HealthcareService";
4120            case IMAGINGSTUDY: return "ImagingStudy";
4121            case IMMUNIZATION: return "Immunization";
4122            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
4123            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
4124            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
4125            case INGREDIENT: return "Ingredient";
4126            case INSURANCEPLAN: return "InsurancePlan";
4127            case INVOICE: return "Invoice";
4128            case LIBRARY: return "Library";
4129            case LINKAGE: return "Linkage";
4130            case LIST: return "List";
4131            case LOCATION: return "Location";
4132            case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition";
4133            case MEASURE: return "Measure";
4134            case MEASUREREPORT: return "MeasureReport";
4135            case MEDICATION: return "Medication";
4136            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
4137            case MEDICATIONDISPENSE: return "MedicationDispense";
4138            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
4139            case MEDICATIONREQUEST: return "MedicationRequest";
4140            case MEDICATIONUSAGE: return "MedicationUsage";
4141            case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition";
4142            case MESSAGEDEFINITION: return "MessageDefinition";
4143            case MESSAGEHEADER: return "MessageHeader";
4144            case MOLECULARSEQUENCE: return "MolecularSequence";
4145            case NAMINGSYSTEM: return "NamingSystem";
4146            case NUTRITIONINTAKE: return "NutritionIntake";
4147            case NUTRITIONORDER: return "NutritionOrder";
4148            case OBSERVATION: return "Observation";
4149            case OBSERVATIONDEFINITION: return "ObservationDefinition";
4150            case OPERATIONDEFINITION: return "OperationDefinition";
4151            case OPERATIONOUTCOME: return "OperationOutcome";
4152            case ORGANIZATION: return "Organization";
4153            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
4154            case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition";
4155            case PARAMETERS: return "Parameters";
4156            case PATIENT: return "Patient";
4157            case PAYMENTNOTICE: return "PaymentNotice";
4158            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
4159            case PERSON: return "Person";
4160            case PLANDEFINITION: return "PlanDefinition";
4161            case PRACTITIONER: return "Practitioner";
4162            case PRACTITIONERROLE: return "PractitionerRole";
4163            case PROCEDURE: return "Procedure";
4164            case PROVENANCE: return "Provenance";
4165            case QUESTIONNAIRE: return "Questionnaire";
4166            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
4167            case REGULATEDAUTHORIZATION: return "RegulatedAuthorization";
4168            case RELATEDPERSON: return "RelatedPerson";
4169            case REQUESTGROUP: return "RequestGroup";
4170            case RESEARCHSTUDY: return "ResearchStudy";
4171            case RESEARCHSUBJECT: return "ResearchSubject";
4172            case RESOURCE: return "Resource";
4173            case RISKASSESSMENT: return "RiskAssessment";
4174            case SCHEDULE: return "Schedule";
4175            case SEARCHPARAMETER: return "SearchParameter";
4176            case SERVICEREQUEST: return "ServiceRequest";
4177            case SLOT: return "Slot";
4178            case SPECIMEN: return "Specimen";
4179            case SPECIMENDEFINITION: return "SpecimenDefinition";
4180            case STRUCTUREDEFINITION: return "StructureDefinition";
4181            case STRUCTUREMAP: return "StructureMap";
4182            case SUBSCRIPTION: return "Subscription";
4183            case SUBSTANCE: return "Substance";
4184            case SUBSTANCEDEFINITION: return "SubstanceDefinition";
4185            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
4186            case SUBSTANCEPOLYMER: return "SubstancePolymer";
4187            case SUBSTANCEPROTEIN: return "SubstanceProtein";
4188            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
4189            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
4190            case SUPPLYDELIVERY: return "SupplyDelivery";
4191            case SUPPLYREQUEST: return "SupplyRequest";
4192            case TASK: return "Task";
4193            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
4194            case TESTREPORT: return "TestReport";
4195            case TESTSCRIPT: return "TestScript";
4196            case TOPIC: return "Topic";
4197            case VALUESET: return "ValueSet";
4198            case VERIFICATIONRESULT: return "VerificationResult";
4199            case VISIONPRESCRIPTION: return "VisionPrescription";
4200            case TYPE: return "Type";
4201            case ANY: return "Any";
4202            default: return "?";
4203          }
4204        }
4205        public String getSystem() {
4206          switch (this) {
4207            case ADDRESS: return "http://hl7.org/fhir/data-types";
4208            case AGE: return "http://hl7.org/fhir/data-types";
4209            case ANNOTATION: return "http://hl7.org/fhir/data-types";
4210            case ATTACHMENT: return "http://hl7.org/fhir/data-types";
4211            case BACKBONEELEMENT: return "http://hl7.org/fhir/data-types";
4212            case BACKBONETYPE: return "http://hl7.org/fhir/data-types";
4213            case BASE: return "http://hl7.org/fhir/data-types";
4214            case CODEABLECONCEPT: return "http://hl7.org/fhir/data-types";
4215            case CODEABLEREFERENCE: return "http://hl7.org/fhir/data-types";
4216            case CODING: return "http://hl7.org/fhir/data-types";
4217            case CONTACTDETAIL: return "http://hl7.org/fhir/data-types";
4218            case CONTACTPOINT: return "http://hl7.org/fhir/data-types";
4219            case CONTRIBUTOR: return "http://hl7.org/fhir/data-types";
4220            case COUNT: return "http://hl7.org/fhir/data-types";
4221            case DATAREQUIREMENT: return "http://hl7.org/fhir/data-types";
4222            case DATATYPE: return "http://hl7.org/fhir/data-types";
4223            case DISTANCE: return "http://hl7.org/fhir/data-types";
4224            case DOSAGE: return "http://hl7.org/fhir/data-types";
4225            case DURATION: return "http://hl7.org/fhir/data-types";
4226            case ELEMENT: return "http://hl7.org/fhir/data-types";
4227            case ELEMENTDEFINITION: return "http://hl7.org/fhir/data-types";
4228            case EXPRESSION: return "http://hl7.org/fhir/data-types";
4229            case EXTENSION: return "http://hl7.org/fhir/data-types";
4230            case HUMANNAME: return "http://hl7.org/fhir/data-types";
4231            case IDENTIFIER: return "http://hl7.org/fhir/data-types";
4232            case MARKETINGSTATUS: return "http://hl7.org/fhir/data-types";
4233            case META: return "http://hl7.org/fhir/data-types";
4234            case MONEY: return "http://hl7.org/fhir/data-types";
4235            case MONEYQUANTITY: return "http://hl7.org/fhir/data-types";
4236            case NARRATIVE: return "http://hl7.org/fhir/data-types";
4237            case ORDEREDDISTRIBUTION: return "http://hl7.org/fhir/data-types";
4238            case PARAMETERDEFINITION: return "http://hl7.org/fhir/data-types";
4239            case PERIOD: return "http://hl7.org/fhir/data-types";
4240            case POPULATION: return "http://hl7.org/fhir/data-types";
4241            case PRIMITIVETYPE: return "http://hl7.org/fhir/data-types";
4242            case PRODCHARACTERISTIC: return "http://hl7.org/fhir/data-types";
4243            case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/data-types";
4244            case QUANTITY: return "http://hl7.org/fhir/data-types";
4245            case RANGE: return "http://hl7.org/fhir/data-types";
4246            case RATIO: return "http://hl7.org/fhir/data-types";
4247            case REFERENCE: return "http://hl7.org/fhir/data-types";
4248            case RELATEDARTIFACT: return "http://hl7.org/fhir/data-types";
4249            case SAMPLEDDATA: return "http://hl7.org/fhir/data-types";
4250            case SIGNATURE: return "http://hl7.org/fhir/data-types";
4251            case SIMPLEQUANTITY: return "http://hl7.org/fhir/data-types";
4252            case STATISTIC: return "http://hl7.org/fhir/data-types";
4253            case SUBSTANCEAMOUNT: return "http://hl7.org/fhir/data-types";
4254            case TIMING: return "http://hl7.org/fhir/data-types";
4255            case TRIGGERDEFINITION: return "http://hl7.org/fhir/data-types";
4256            case USAGECONTEXT: return "http://hl7.org/fhir/data-types";
4257            case BASE64BINARY: return "http://hl7.org/fhir/data-types";
4258            case BOOLEAN: return "http://hl7.org/fhir/data-types";
4259            case CANONICAL: return "http://hl7.org/fhir/data-types";
4260            case CODE: return "http://hl7.org/fhir/data-types";
4261            case DATE: return "http://hl7.org/fhir/data-types";
4262            case DATETIME: return "http://hl7.org/fhir/data-types";
4263            case DECIMAL: return "http://hl7.org/fhir/data-types";
4264            case ID: return "http://hl7.org/fhir/data-types";
4265            case INSTANT: return "http://hl7.org/fhir/data-types";
4266            case INTEGER: return "http://hl7.org/fhir/data-types";
4267            case INTEGER64: return "http://hl7.org/fhir/data-types";
4268            case MARKDOWN: return "http://hl7.org/fhir/data-types";
4269            case OID: return "http://hl7.org/fhir/data-types";
4270            case POSITIVEINT: return "http://hl7.org/fhir/data-types";
4271            case STRING: return "http://hl7.org/fhir/data-types";
4272            case TIME: return "http://hl7.org/fhir/data-types";
4273            case UNSIGNEDINT: return "http://hl7.org/fhir/data-types";
4274            case URI: return "http://hl7.org/fhir/data-types";
4275            case URL: return "http://hl7.org/fhir/data-types";
4276            case UUID: return "http://hl7.org/fhir/data-types";
4277            case XHTML: return "http://hl7.org/fhir/data-types";
4278            case ACCOUNT: return "http://hl7.org/fhir/resource-types";
4279            case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types";
4280            case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
4281            case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types";
4282            case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types";
4283            case APPOINTMENT: return "http://hl7.org/fhir/resource-types";
4284            case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
4285            case AUDITEVENT: return "http://hl7.org/fhir/resource-types";
4286            case BASIC: return "http://hl7.org/fhir/resource-types";
4287            case BINARY: return "http://hl7.org/fhir/resource-types";
4288            case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types";
4289            case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types";
4290            case BUNDLE: return "http://hl7.org/fhir/resource-types";
4291            case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types";
4292            case CAPABILITYSTATEMENT2: return "http://hl7.org/fhir/resource-types";
4293            case CAREPLAN: return "http://hl7.org/fhir/resource-types";
4294            case CARETEAM: return "http://hl7.org/fhir/resource-types";
4295            case CATALOGENTRY: return "http://hl7.org/fhir/resource-types";
4296            case CHARGEITEM: return "http://hl7.org/fhir/resource-types";
4297            case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
4298            case CLAIM: return "http://hl7.org/fhir/resource-types";
4299            case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types";
4300            case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types";
4301            case CLINICALUSEISSUE: return "http://hl7.org/fhir/resource-types";
4302            case CODESYSTEM: return "http://hl7.org/fhir/resource-types";
4303            case COMMUNICATION: return "http://hl7.org/fhir/resource-types";
4304            case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
4305            case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
4306            case COMPOSITION: return "http://hl7.org/fhir/resource-types";
4307            case CONCEPTMAP: return "http://hl7.org/fhir/resource-types";
4308            case CONDITION: return "http://hl7.org/fhir/resource-types";
4309            case CONDITIONDEFINITION: return "http://hl7.org/fhir/resource-types";
4310            case CONSENT: return "http://hl7.org/fhir/resource-types";
4311            case CONTRACT: return "http://hl7.org/fhir/resource-types";
4312            case COVERAGE: return "http://hl7.org/fhir/resource-types";
4313            case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types";
4314            case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types";
4315            case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types";
4316            case DEVICE: return "http://hl7.org/fhir/resource-types";
4317            case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types";
4318            case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types";
4319            case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types";
4320            case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types";
4321            case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types";
4322            case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types";
4323            case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types";
4324            case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types";
4325            case ENCOUNTER: return "http://hl7.org/fhir/resource-types";
4326            case ENDPOINT: return "http://hl7.org/fhir/resource-types";
4327            case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types";
4328            case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
4329            case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types";
4330            case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types";
4331            case EVIDENCE: return "http://hl7.org/fhir/resource-types";
4332            case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types";
4333            case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types";
4334            case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types";
4335            case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types";
4336            case FLAG: return "http://hl7.org/fhir/resource-types";
4337            case GOAL: return "http://hl7.org/fhir/resource-types";
4338            case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types";
4339            case GROUP: return "http://hl7.org/fhir/resource-types";
4340            case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types";
4341            case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types";
4342            case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types";
4343            case IMMUNIZATION: return "http://hl7.org/fhir/resource-types";
4344            case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types";
4345            case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types";
4346            case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types";
4347            case INGREDIENT: return "http://hl7.org/fhir/resource-types";
4348            case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types";
4349            case INVOICE: return "http://hl7.org/fhir/resource-types";
4350            case LIBRARY: return "http://hl7.org/fhir/resource-types";
4351            case LINKAGE: return "http://hl7.org/fhir/resource-types";
4352            case LIST: return "http://hl7.org/fhir/resource-types";
4353            case LOCATION: return "http://hl7.org/fhir/resource-types";
4354            case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
4355            case MEASURE: return "http://hl7.org/fhir/resource-types";
4356            case MEASUREREPORT: return "http://hl7.org/fhir/resource-types";
4357            case MEDICATION: return "http://hl7.org/fhir/resource-types";
4358            case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types";
4359            case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types";
4360            case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types";
4361            case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
4362            case MEDICATIONUSAGE: return "http://hl7.org/fhir/resource-types";
4363            case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
4364            case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types";
4365            case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types";
4366            case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types";
4367            case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types";
4368            case NUTRITIONINTAKE: return "http://hl7.org/fhir/resource-types";
4369            case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types";
4370            case OBSERVATION: return "http://hl7.org/fhir/resource-types";
4371            case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
4372            case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
4373            case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types";
4374            case ORGANIZATION: return "http://hl7.org/fhir/resource-types";
4375            case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types";
4376            case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
4377            case PARAMETERS: return "http://hl7.org/fhir/resource-types";
4378            case PATIENT: return "http://hl7.org/fhir/resource-types";
4379            case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types";
4380            case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types";
4381            case PERSON: return "http://hl7.org/fhir/resource-types";
4382            case PLANDEFINITION: return "http://hl7.org/fhir/resource-types";
4383            case PRACTITIONER: return "http://hl7.org/fhir/resource-types";
4384            case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types";
4385            case PROCEDURE: return "http://hl7.org/fhir/resource-types";
4386            case PROVENANCE: return "http://hl7.org/fhir/resource-types";
4387            case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types";
4388            case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types";
4389            case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/resource-types";
4390            case RELATEDPERSON: return "http://hl7.org/fhir/resource-types";
4391            case REQUESTGROUP: return "http://hl7.org/fhir/resource-types";
4392            case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types";
4393            case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types";
4394            case RESOURCE: return "http://hl7.org/fhir/resource-types";
4395            case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types";
4396            case SCHEDULE: return "http://hl7.org/fhir/resource-types";
4397            case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types";
4398            case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types";
4399            case SLOT: return "http://hl7.org/fhir/resource-types";
4400            case SPECIMEN: return "http://hl7.org/fhir/resource-types";
4401            case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types";
4402            case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types";
4403            case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types";
4404            case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types";
4405            case SUBSTANCE: return "http://hl7.org/fhir/resource-types";
4406            case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/resource-types";
4407            case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types";
4408            case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types";
4409            case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types";
4410            case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types";
4411            case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types";
4412            case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types";
4413            case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types";
4414            case TASK: return "http://hl7.org/fhir/resource-types";
4415            case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types";
4416            case TESTREPORT: return "http://hl7.org/fhir/resource-types";
4417            case TESTSCRIPT: return "http://hl7.org/fhir/resource-types";
4418            case TOPIC: return "http://hl7.org/fhir/resource-types";
4419            case VALUESET: return "http://hl7.org/fhir/resource-types";
4420            case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types";
4421            case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types";
4422            case TYPE: return "http://hl7.org/fhir/abstract-types";
4423            case ANY: return "http://hl7.org/fhir/abstract-types";
4424            default: return "?";
4425          }
4426        }
4427        public String getDefinition() {
4428          switch (this) {
4429            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.";
4430            case AGE: return "A duration of time during which an organism (or a process) has existed.";
4431            case ANNOTATION: return "A  text note which also  contains information about who made the statement and when.";
4432            case ATTACHMENT: return "For referring to data content defined in other formats.";
4433            case BACKBONEELEMENT: return "Base definition for all elements that are defined inside a resource - but not those in a data type.";
4434            case BACKBONETYPE: return "Base definition for the few data types that are allowed to carry modifier extensions.";
4435            case BASE: return "Base definition for all types defined in FHIR type system.";
4436            case CODEABLECONCEPT: return "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.";
4437            case CODEABLEREFERENCE: return "A reference to a resource (by instance), or instead, a reference to a cencept defined in a terminology or ontology (by class).";
4438            case CODING: return "A reference to a code defined by a terminology system.";
4439            case CONTACTDETAIL: return "Specifies contact information for a person or organization.";
4440            case CONTACTPOINT: return "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.";
4441            case CONTRIBUTOR: return "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.";
4442            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.";
4443            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.";
4444            case DATATYPE: return "The base class for all re-useable types defined as part of the FHIR Specification.";
4445            case DISTANCE: return "A length - a value with a unit that is a physical distance.";
4446            case DOSAGE: return "Indicates how the medication is/was taken or should be taken by the patient.";
4447            case DURATION: return "A length of time.";
4448            case ELEMENT: return "Base definition for all elements in a resource.";
4449            case ELEMENTDEFINITION: return "Captures constraints on each element within the resource, profile, or extension.";
4450            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.";
4451            case EXTENSION: return "Optional Extension Element - found in all resources.";
4452            case HUMANNAME: return "A human's name with the ability to identify parts and usage.";
4453            case IDENTIFIER: return "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.";
4454            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.";
4455            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.";
4456            case MONEY: return "An amount of economic utility in some recognized currency.";
4457            case MONEYQUANTITY: return "";
4458            case NARRATIVE: return "A human-readable summary of the resource conveying the essential clinical and business information for the resource.";
4459            case ORDEREDDISTRIBUTION: return "An ordered list (distribution) of statistics.";
4460            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.";
4461            case PERIOD: return "A time period defined by a start and end date and optionally time.";
4462            case POPULATION: return "A populatioof people with some set of grouping criteria.";
4463            case PRIMITIVETYPE: return "The base type for all re-useable types defined that have a simple property.";
4464            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.";
4465            case PRODUCTSHELFLIFE: return "The shelf-life and storage information for a medicinal product item or container can be described using this class.";
4466            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.";
4467            case RANGE: return "A set of ordered Quantities defined by a low and high limit.";
4468            case RATIO: return "A relationship of two Quantity values - expressed as a numerator and a denominator.";
4469            case REFERENCE: return "A reference from one resource to another.";
4470            case RELATEDARTIFACT: return "Related artifacts such as additional documentation, justification, or bibliographic references.";
4471            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.";
4472            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.";
4473            case SIMPLEQUANTITY: return "";
4474            case STATISTIC: return "A fact or piece of data from a  study of a large quantity of numerical data.  A mathematical or quantified characteristic of a group of observations.";
4475            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.";
4476            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.";
4477            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.";
4478            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).";
4479            case BASE64BINARY: return "A stream of bytes";
4480            case BOOLEAN: return "Value of \"true\" or \"false\"";
4481            case CANONICAL: return "A URI that is a reference to a canonical URL on a FHIR resource";
4482            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";
4483            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.";
4484            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.";
4485            case DECIMAL: return "A rational number with implicit precision";
4486            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.";
4487            case INSTANT: return "An instant in time - known at least to the second";
4488            case INTEGER: return "A whole number";
4489            case INTEGER64: return "A very large whole number";
4490            case MARKDOWN: return "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine";
4491            case OID: return "An OID represented as a URI";
4492            case POSITIVEINT: return "An integer with a value that is positive (e.g. >0)";
4493            case STRING: return "A sequence of Unicode characters";
4494            case TIME: return "A time during the day, with no date specified";
4495            case UNSIGNEDINT: return "An integer with a value that is not negative (e.g. >= 0)";
4496            case URI: return "String of characters used to identify a name or a resource";
4497            case URL: return "A URI that is a literal reference";
4498            case UUID: return "A UUID, represented as a URI";
4499            case XHTML: return "XHTML format, as defined by W3C, but restricted usage (mainly, no active content)";
4500            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.";
4501            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.";
4502            case ADMINISTRABLEPRODUCTDEFINITION: return "A pharmaceutical product described in terms of its composition and dose form.";
4503            case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject.  The unintended effects may require additional monitoring, treatment or hospitalization or may result in death.  The AdverseEvent resource also extends to potential or avoided events that could have had such effects.";
4504            case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.";
4505            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).";
4506            case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.";
4507            case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis.";
4508            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.";
4509            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.";
4510            case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity.";
4511            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.";
4512            case BUNDLE: return "A container for a collection of resources.";
4513            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.";
4514            case CAPABILITYSTATEMENT2: 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.";
4515            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.";
4516            case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care.";
4517            case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog.";
4518            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.";
4519            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.";
4520            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.";
4521            case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource.";
4522            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.";
4523            case CLINICALUSEISSUE: return "A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure.";
4524            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.";
4525            case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition.";
4526            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.";
4527            case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server.";
4528            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.).";
4529            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.";
4530            case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.";
4531            case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it.";
4532            case CONSENT: return "A record of a healthcare consumer’s  choices  or choices made on their behalf by a third party, 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.";
4533            case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.";
4534            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.";
4535            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.";
4536            case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.";
4537            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.";
4538            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.";
4539            case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device.";
4540            case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device.";
4541            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.";
4542            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.";
4543            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.";
4544            case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection.";
4545            case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this \"document\" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare.  The DocumentReference resource provides metadata about the document so that the document can be discovered and managed.  The actual content may be inline base64 encoded data or provided by direct reference.";
4546            case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources.";
4547            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.";
4548            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.";
4549            case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage.";
4550            case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.";
4551            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.";
4552            case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur.";
4553            case EVIDENCE: return "This represents statistics, certainty, both the intended and actual population, and evidence variables.";
4554            case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about.";
4555            case EXAMPLESCENARIO: return "Example of workflow instance.";
4556            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.";
4557            case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient.";
4558            case FLAG: return "Prospective warnings of potential issues when providing care to the patient.";
4559            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.";
4560            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.";
4561            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.";
4562            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.";
4563            case HEALTHCARESERVICE: return "The details of a healthcare service available at a location.";
4564            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.";
4565            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.";
4566            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.";
4567            case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.";
4568            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.";
4569            case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product.";
4570            case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization.";
4571            case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.";
4572            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.";
4573            case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\".";
4574            case LIST: return "A list is a curated collection of resources.";
4575            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.";
4576            case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product.";
4577            case MEASURE: return "The Measure resource provides the definition of a quality measure.";
4578            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.";
4579            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.";
4580            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.";
4581            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.";
4582            case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge.";
4583            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.";
4584            case MEDICATIONUSAGE: return "A record of a medication that is being consumed by a patient.   A MedicationUsage 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 medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medicationusage 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 Usage 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.";
4585            case MEDICINALPRODUCTDEFINITION: return "Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).";
4586            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.";
4587            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.";
4588            case MOLECULARSEQUENCE: return "Raw data describing a biological sequence.";
4589            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.";
4590            case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient.   A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past.  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 or through an app that tracks food or fluids consumed.   The consumption information may come from sources such as the patient's memory, from a nutrition label,  or from a clinician documenting observed intake.";
4591            case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.";
4592            case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject.";
4593            case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.";
4594            case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).";
4595            case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action.";
4596            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.";
4597            case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.";
4598            case PACKAGEDPRODUCTDEFINITION: return "A medicinal product in a container or package.";
4599            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.";
4600            case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services.";
4601            case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references.";
4602            case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid.";
4603            case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context.";
4604            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.";
4605            case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare.";
4606            case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.";
4607            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.";
4608            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.";
4609            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.";
4610            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.";
4611            case REGULATEDAUTHORIZATION: return "The regulatory authorization of a medicinal product.";
4612            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.";
4613            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\".";
4614            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.";
4615            case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study.";
4616            case RESOURCE: return "This is the base resource type for everything.";
4617            case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.";
4618            case SCHEDULE: return "A container for slots of time that may be available for booking appointments.";
4619            case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource.";
4620            case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.";
4621            case SLOT: return "A slot of time on a schedule that may be available for booking appointments.";
4622            case SPECIMEN: return "A sample to be used for analysis.";
4623            case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements.";
4624            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.";
4625            case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data.";
4626            case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a Topic.";
4627            case SUBSTANCE: return "A homogeneous material with a definite composition.";
4628            case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing.";
4629            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.";
4630            case SUBSTANCEPOLYMER: return "Todo.";
4631            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.";
4632            case SUBSTANCEREFERENCEINFORMATION: return "Todo.";
4633            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.";
4634            case SUPPLYDELIVERY: return "Record of delivery of what is supplied.";
4635            case SUPPLYREQUEST: return "A record of a request for a medication, substance or device used in the healthcare setting.";
4636            case TASK: return "A task to be performed.";
4637            case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.";
4638            case TESTREPORT: return "A summary of information based on the results of executing a TestScript.";
4639            case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.";
4640            case TOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic.";
4641            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).";
4642            case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements.";
4643            case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient.";
4644            case TYPE: return "A place holder that means any kind of data type";
4645            case ANY: return "A place holder that means any kind of resource";
4646            default: return "?";
4647          }
4648        }
4649        public String getDisplay() {
4650          switch (this) {
4651            case ADDRESS: return "Address";
4652            case AGE: return "Age";
4653            case ANNOTATION: return "Annotation";
4654            case ATTACHMENT: return "Attachment";
4655            case BACKBONEELEMENT: return "BackboneElement";
4656            case BACKBONETYPE: return "BackboneType";
4657            case BASE: return "Base";
4658            case CODEABLECONCEPT: return "CodeableConcept";
4659            case CODEABLEREFERENCE: return "CodeableReference";
4660            case CODING: return "Coding";
4661            case CONTACTDETAIL: return "ContactDetail";
4662            case CONTACTPOINT: return "ContactPoint";
4663            case CONTRIBUTOR: return "Contributor";
4664            case COUNT: return "Count";
4665            case DATAREQUIREMENT: return "DataRequirement";
4666            case DATATYPE: return "DataType";
4667            case DISTANCE: return "Distance";
4668            case DOSAGE: return "Dosage";
4669            case DURATION: return "Duration";
4670            case ELEMENT: return "Element";
4671            case ELEMENTDEFINITION: return "ElementDefinition";
4672            case EXPRESSION: return "Expression";
4673            case EXTENSION: return "Extension";
4674            case HUMANNAME: return "HumanName";
4675            case IDENTIFIER: return "Identifier";
4676            case MARKETINGSTATUS: return "MarketingStatus";
4677            case META: return "Meta";
4678            case MONEY: return "Money";
4679            case MONEYQUANTITY: return "MoneyQuantity";
4680            case NARRATIVE: return "Narrative";
4681            case ORDEREDDISTRIBUTION: return "OrderedDistribution";
4682            case PARAMETERDEFINITION: return "ParameterDefinition";
4683            case PERIOD: return "Period";
4684            case POPULATION: return "Population";
4685            case PRIMITIVETYPE: return "PrimitiveType";
4686            case PRODCHARACTERISTIC: return "ProdCharacteristic";
4687            case PRODUCTSHELFLIFE: return "ProductShelfLife";
4688            case QUANTITY: return "Quantity";
4689            case RANGE: return "Range";
4690            case RATIO: return "Ratio";
4691            case REFERENCE: return "Reference";
4692            case RELATEDARTIFACT: return "RelatedArtifact";
4693            case SAMPLEDDATA: return "SampledData";
4694            case SIGNATURE: return "Signature";
4695            case SIMPLEQUANTITY: return "SimpleQuantity";
4696            case STATISTIC: return "Statistic";
4697            case SUBSTANCEAMOUNT: return "SubstanceAmount";
4698            case TIMING: return "Timing";
4699            case TRIGGERDEFINITION: return "TriggerDefinition";
4700            case USAGECONTEXT: return "UsageContext";
4701            case BASE64BINARY: return "base64Binary";
4702            case BOOLEAN: return "boolean";
4703            case CANONICAL: return "canonical";
4704            case CODE: return "code";
4705            case DATE: return "date";
4706            case DATETIME: return "dateTime";
4707            case DECIMAL: return "decimal";
4708            case ID: return "id";
4709            case INSTANT: return "instant";
4710            case INTEGER: return "integer";
4711            case INTEGER64: return "integer64";
4712            case MARKDOWN: return "markdown";
4713            case OID: return "oid";
4714            case POSITIVEINT: return "positiveInt";
4715            case STRING: return "string";
4716            case TIME: return "time";
4717            case UNSIGNEDINT: return "unsignedInt";
4718            case URI: return "uri";
4719            case URL: return "url";
4720            case UUID: return "uuid";
4721            case XHTML: return "XHTML";
4722            case ACCOUNT: return "Account";
4723            case ACTIVITYDEFINITION: return "ActivityDefinition";
4724            case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition";
4725            case ADVERSEEVENT: return "AdverseEvent";
4726            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
4727            case APPOINTMENT: return "Appointment";
4728            case APPOINTMENTRESPONSE: return "AppointmentResponse";
4729            case AUDITEVENT: return "AuditEvent";
4730            case BASIC: return "Basic";
4731            case BINARY: return "Binary";
4732            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
4733            case BODYSTRUCTURE: return "BodyStructure";
4734            case BUNDLE: return "Bundle";
4735            case CAPABILITYSTATEMENT: return "CapabilityStatement";
4736            case CAPABILITYSTATEMENT2: return "CapabilityStatement2";
4737            case CAREPLAN: return "CarePlan";
4738            case CARETEAM: return "CareTeam";
4739            case CATALOGENTRY: return "CatalogEntry";
4740            case CHARGEITEM: return "ChargeItem";
4741            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
4742            case CLAIM: return "Claim";
4743            case CLAIMRESPONSE: return "ClaimResponse";
4744            case CLINICALIMPRESSION: return "ClinicalImpression";
4745            case CLINICALUSEISSUE: return "ClinicalUseIssue";
4746            case CODESYSTEM: return "CodeSystem";
4747            case COMMUNICATION: return "Communication";
4748            case COMMUNICATIONREQUEST: return "CommunicationRequest";
4749            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
4750            case COMPOSITION: return "Composition";
4751            case CONCEPTMAP: return "ConceptMap";
4752            case CONDITION: return "Condition";
4753            case CONDITIONDEFINITION: return "ConditionDefinition";
4754            case CONSENT: return "Consent";
4755            case CONTRACT: return "Contract";
4756            case COVERAGE: return "Coverage";
4757            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
4758            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
4759            case DETECTEDISSUE: return "DetectedIssue";
4760            case DEVICE: return "Device";
4761            case DEVICEDEFINITION: return "DeviceDefinition";
4762            case DEVICEMETRIC: return "DeviceMetric";
4763            case DEVICEREQUEST: return "DeviceRequest";
4764            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
4765            case DIAGNOSTICREPORT: return "DiagnosticReport";
4766            case DOCUMENTMANIFEST: return "DocumentManifest";
4767            case DOCUMENTREFERENCE: return "DocumentReference";
4768            case DOMAINRESOURCE: return "DomainResource";
4769            case ENCOUNTER: return "Encounter";
4770            case ENDPOINT: return "Endpoint";
4771            case ENROLLMENTREQUEST: return "EnrollmentRequest";
4772            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
4773            case EPISODEOFCARE: return "EpisodeOfCare";
4774            case EVENTDEFINITION: return "EventDefinition";
4775            case EVIDENCE: return "Evidence";
4776            case EVIDENCEVARIABLE: return "EvidenceVariable";
4777            case EXAMPLESCENARIO: return "ExampleScenario";
4778            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
4779            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
4780            case FLAG: return "Flag";
4781            case GOAL: return "Goal";
4782            case GRAPHDEFINITION: return "GraphDefinition";
4783            case GROUP: return "Group";
4784            case GUIDANCERESPONSE: return "GuidanceResponse";
4785            case HEALTHCARESERVICE: return "HealthcareService";
4786            case IMAGINGSTUDY: return "ImagingStudy";
4787            case IMMUNIZATION: return "Immunization";
4788            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
4789            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
4790            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
4791            case INGREDIENT: return "Ingredient";
4792            case INSURANCEPLAN: return "InsurancePlan";
4793            case INVOICE: return "Invoice";
4794            case LIBRARY: return "Library";
4795            case LINKAGE: return "Linkage";
4796            case LIST: return "List";
4797            case LOCATION: return "Location";
4798            case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition";
4799            case MEASURE: return "Measure";
4800            case MEASUREREPORT: return "MeasureReport";
4801            case MEDICATION: return "Medication";
4802            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
4803            case MEDICATIONDISPENSE: return "MedicationDispense";
4804            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
4805            case MEDICATIONREQUEST: return "MedicationRequest";
4806            case MEDICATIONUSAGE: return "MedicationUsage";
4807            case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition";
4808            case MESSAGEDEFINITION: return "MessageDefinition";
4809            case MESSAGEHEADER: return "MessageHeader";
4810            case MOLECULARSEQUENCE: return "MolecularSequence";
4811            case NAMINGSYSTEM: return "NamingSystem";
4812            case NUTRITIONINTAKE: return "NutritionIntake";
4813            case NUTRITIONORDER: return "NutritionOrder";
4814            case OBSERVATION: return "Observation";
4815            case OBSERVATIONDEFINITION: return "ObservationDefinition";
4816            case OPERATIONDEFINITION: return "OperationDefinition";
4817            case OPERATIONOUTCOME: return "OperationOutcome";
4818            case ORGANIZATION: return "Organization";
4819            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
4820            case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition";
4821            case PARAMETERS: return "Parameters";
4822            case PATIENT: return "Patient";
4823            case PAYMENTNOTICE: return "PaymentNotice";
4824            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
4825            case PERSON: return "Person";
4826            case PLANDEFINITION: return "PlanDefinition";
4827            case PRACTITIONER: return "Practitioner";
4828            case PRACTITIONERROLE: return "PractitionerRole";
4829            case PROCEDURE: return "Procedure";
4830            case PROVENANCE: return "Provenance";
4831            case QUESTIONNAIRE: return "Questionnaire";
4832            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
4833            case REGULATEDAUTHORIZATION: return "RegulatedAuthorization";
4834            case RELATEDPERSON: return "RelatedPerson";
4835            case REQUESTGROUP: return "RequestGroup";
4836            case RESEARCHSTUDY: return "ResearchStudy";
4837            case RESEARCHSUBJECT: return "ResearchSubject";
4838            case RESOURCE: return "Resource";
4839            case RISKASSESSMENT: return "RiskAssessment";
4840            case SCHEDULE: return "Schedule";
4841            case SEARCHPARAMETER: return "SearchParameter";
4842            case SERVICEREQUEST: return "ServiceRequest";
4843            case SLOT: return "Slot";
4844            case SPECIMEN: return "Specimen";
4845            case SPECIMENDEFINITION: return "SpecimenDefinition";
4846            case STRUCTUREDEFINITION: return "StructureDefinition";
4847            case STRUCTUREMAP: return "StructureMap";
4848            case SUBSCRIPTION: return "Subscription";
4849            case SUBSTANCE: return "Substance";
4850            case SUBSTANCEDEFINITION: return "SubstanceDefinition";
4851            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
4852            case SUBSTANCEPOLYMER: return "SubstancePolymer";
4853            case SUBSTANCEPROTEIN: return "SubstanceProtein";
4854            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
4855            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
4856            case SUPPLYDELIVERY: return "SupplyDelivery";
4857            case SUPPLYREQUEST: return "SupplyRequest";
4858            case TASK: return "Task";
4859            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
4860            case TESTREPORT: return "TestReport";
4861            case TESTSCRIPT: return "TestScript";
4862            case TOPIC: return "Topic";
4863            case VALUESET: return "ValueSet";
4864            case VERIFICATIONRESULT: return "VerificationResult";
4865            case VISIONPRESCRIPTION: return "VisionPrescription";
4866            case TYPE: return "Type";
4867            case ANY: return "Any";
4868            default: return "?";
4869          }
4870        }
4871    }
4872
4873  public static class FHIRAllTypesEnumFactory implements EnumFactory<FHIRAllTypes> {
4874    public FHIRAllTypes fromCode(String codeString) throws IllegalArgumentException {
4875      if (codeString == null || "".equals(codeString))
4876            if (codeString == null || "".equals(codeString))
4877                return null;
4878        if ("Address".equals(codeString))
4879          return FHIRAllTypes.ADDRESS;
4880        if ("Age".equals(codeString))
4881          return FHIRAllTypes.AGE;
4882        if ("Annotation".equals(codeString))
4883          return FHIRAllTypes.ANNOTATION;
4884        if ("Attachment".equals(codeString))
4885          return FHIRAllTypes.ATTACHMENT;
4886        if ("BackboneElement".equals(codeString))
4887          return FHIRAllTypes.BACKBONEELEMENT;
4888        if ("BackboneType".equals(codeString))
4889          return FHIRAllTypes.BACKBONETYPE;
4890        if ("Base".equals(codeString))
4891          return FHIRAllTypes.BASE;
4892        if ("CodeableConcept".equals(codeString))
4893          return FHIRAllTypes.CODEABLECONCEPT;
4894        if ("CodeableReference".equals(codeString))
4895          return FHIRAllTypes.CODEABLEREFERENCE;
4896        if ("Coding".equals(codeString))
4897          return FHIRAllTypes.CODING;
4898        if ("ContactDetail".equals(codeString))
4899          return FHIRAllTypes.CONTACTDETAIL;
4900        if ("ContactPoint".equals(codeString))
4901          return FHIRAllTypes.CONTACTPOINT;
4902        if ("Contributor".equals(codeString))
4903          return FHIRAllTypes.CONTRIBUTOR;
4904        if ("Count".equals(codeString))
4905          return FHIRAllTypes.COUNT;
4906        if ("DataRequirement".equals(codeString))
4907          return FHIRAllTypes.DATAREQUIREMENT;
4908        if ("DataType".equals(codeString))
4909          return FHIRAllTypes.DATATYPE;
4910        if ("Distance".equals(codeString))
4911          return FHIRAllTypes.DISTANCE;
4912        if ("Dosage".equals(codeString))
4913          return FHIRAllTypes.DOSAGE;
4914        if ("Duration".equals(codeString))
4915          return FHIRAllTypes.DURATION;
4916        if ("Element".equals(codeString))
4917          return FHIRAllTypes.ELEMENT;
4918        if ("ElementDefinition".equals(codeString))
4919          return FHIRAllTypes.ELEMENTDEFINITION;
4920        if ("Expression".equals(codeString))
4921          return FHIRAllTypes.EXPRESSION;
4922        if ("Extension".equals(codeString))
4923          return FHIRAllTypes.EXTENSION;
4924        if ("HumanName".equals(codeString))
4925          return FHIRAllTypes.HUMANNAME;
4926        if ("Identifier".equals(codeString))
4927          return FHIRAllTypes.IDENTIFIER;
4928        if ("MarketingStatus".equals(codeString))
4929          return FHIRAllTypes.MARKETINGSTATUS;
4930        if ("Meta".equals(codeString))
4931          return FHIRAllTypes.META;
4932        if ("Money".equals(codeString))
4933          return FHIRAllTypes.MONEY;
4934        if ("MoneyQuantity".equals(codeString))
4935          return FHIRAllTypes.MONEYQUANTITY;
4936        if ("Narrative".equals(codeString))
4937          return FHIRAllTypes.NARRATIVE;
4938        if ("OrderedDistribution".equals(codeString))
4939          return FHIRAllTypes.ORDEREDDISTRIBUTION;
4940        if ("ParameterDefinition".equals(codeString))
4941          return FHIRAllTypes.PARAMETERDEFINITION;
4942        if ("Period".equals(codeString))
4943          return FHIRAllTypes.PERIOD;
4944        if ("Population".equals(codeString))
4945          return FHIRAllTypes.POPULATION;
4946        if ("PrimitiveType".equals(codeString))
4947          return FHIRAllTypes.PRIMITIVETYPE;
4948        if ("ProdCharacteristic".equals(codeString))
4949          return FHIRAllTypes.PRODCHARACTERISTIC;
4950        if ("ProductShelfLife".equals(codeString))
4951          return FHIRAllTypes.PRODUCTSHELFLIFE;
4952        if ("Quantity".equals(codeString))
4953          return FHIRAllTypes.QUANTITY;
4954        if ("Range".equals(codeString))
4955          return FHIRAllTypes.RANGE;
4956        if ("Ratio".equals(codeString))
4957          return FHIRAllTypes.RATIO;
4958        if ("Reference".equals(codeString))
4959          return FHIRAllTypes.REFERENCE;
4960        if ("RelatedArtifact".equals(codeString))
4961          return FHIRAllTypes.RELATEDARTIFACT;
4962        if ("SampledData".equals(codeString))
4963          return FHIRAllTypes.SAMPLEDDATA;
4964        if ("Signature".equals(codeString))
4965          return FHIRAllTypes.SIGNATURE;
4966        if ("SimpleQuantity".equals(codeString))
4967          return FHIRAllTypes.SIMPLEQUANTITY;
4968        if ("Statistic".equals(codeString))
4969          return FHIRAllTypes.STATISTIC;
4970        if ("SubstanceAmount".equals(codeString))
4971          return FHIRAllTypes.SUBSTANCEAMOUNT;
4972        if ("Timing".equals(codeString))
4973          return FHIRAllTypes.TIMING;
4974        if ("TriggerDefinition".equals(codeString))
4975          return FHIRAllTypes.TRIGGERDEFINITION;
4976        if ("UsageContext".equals(codeString))
4977          return FHIRAllTypes.USAGECONTEXT;
4978        if ("base64Binary".equals(codeString))
4979          return FHIRAllTypes.BASE64BINARY;
4980        if ("boolean".equals(codeString))
4981          return FHIRAllTypes.BOOLEAN;
4982        if ("canonical".equals(codeString))
4983          return FHIRAllTypes.CANONICAL;
4984        if ("code".equals(codeString))
4985          return FHIRAllTypes.CODE;
4986        if ("date".equals(codeString))
4987          return FHIRAllTypes.DATE;
4988        if ("dateTime".equals(codeString))
4989          return FHIRAllTypes.DATETIME;
4990        if ("decimal".equals(codeString))
4991          return FHIRAllTypes.DECIMAL;
4992        if ("id".equals(codeString))
4993          return FHIRAllTypes.ID;
4994        if ("instant".equals(codeString))
4995          return FHIRAllTypes.INSTANT;
4996        if ("integer".equals(codeString))
4997          return FHIRAllTypes.INTEGER;
4998        if ("integer64".equals(codeString))
4999          return FHIRAllTypes.INTEGER64;
5000        if ("markdown".equals(codeString))
5001          return FHIRAllTypes.MARKDOWN;
5002        if ("oid".equals(codeString))
5003          return FHIRAllTypes.OID;
5004        if ("positiveInt".equals(codeString))
5005          return FHIRAllTypes.POSITIVEINT;
5006        if ("string".equals(codeString))
5007          return FHIRAllTypes.STRING;
5008        if ("time".equals(codeString))
5009          return FHIRAllTypes.TIME;
5010        if ("unsignedInt".equals(codeString))
5011          return FHIRAllTypes.UNSIGNEDINT;
5012        if ("uri".equals(codeString))
5013          return FHIRAllTypes.URI;
5014        if ("url".equals(codeString))
5015          return FHIRAllTypes.URL;
5016        if ("uuid".equals(codeString))
5017          return FHIRAllTypes.UUID;
5018        if ("xhtml".equals(codeString))
5019          return FHIRAllTypes.XHTML;
5020        if ("Account".equals(codeString))
5021          return FHIRAllTypes.ACCOUNT;
5022        if ("ActivityDefinition".equals(codeString))
5023          return FHIRAllTypes.ACTIVITYDEFINITION;
5024        if ("AdministrableProductDefinition".equals(codeString))
5025          return FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION;
5026        if ("AdverseEvent".equals(codeString))
5027          return FHIRAllTypes.ADVERSEEVENT;
5028        if ("AllergyIntolerance".equals(codeString))
5029          return FHIRAllTypes.ALLERGYINTOLERANCE;
5030        if ("Appointment".equals(codeString))
5031          return FHIRAllTypes.APPOINTMENT;
5032        if ("AppointmentResponse".equals(codeString))
5033          return FHIRAllTypes.APPOINTMENTRESPONSE;
5034        if ("AuditEvent".equals(codeString))
5035          return FHIRAllTypes.AUDITEVENT;
5036        if ("Basic".equals(codeString))
5037          return FHIRAllTypes.BASIC;
5038        if ("Binary".equals(codeString))
5039          return FHIRAllTypes.BINARY;
5040        if ("BiologicallyDerivedProduct".equals(codeString))
5041          return FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT;
5042        if ("BodyStructure".equals(codeString))
5043          return FHIRAllTypes.BODYSTRUCTURE;
5044        if ("Bundle".equals(codeString))
5045          return FHIRAllTypes.BUNDLE;
5046        if ("CapabilityStatement".equals(codeString))
5047          return FHIRAllTypes.CAPABILITYSTATEMENT;
5048        if ("CapabilityStatement2".equals(codeString))
5049          return FHIRAllTypes.CAPABILITYSTATEMENT2;
5050        if ("CarePlan".equals(codeString))
5051          return FHIRAllTypes.CAREPLAN;
5052        if ("CareTeam".equals(codeString))
5053          return FHIRAllTypes.CARETEAM;
5054        if ("CatalogEntry".equals(codeString))
5055          return FHIRAllTypes.CATALOGENTRY;
5056        if ("ChargeItem".equals(codeString))
5057          return FHIRAllTypes.CHARGEITEM;
5058        if ("ChargeItemDefinition".equals(codeString))
5059          return FHIRAllTypes.CHARGEITEMDEFINITION;
5060        if ("Claim".equals(codeString))
5061          return FHIRAllTypes.CLAIM;
5062        if ("ClaimResponse".equals(codeString))
5063          return FHIRAllTypes.CLAIMRESPONSE;
5064        if ("ClinicalImpression".equals(codeString))
5065          return FHIRAllTypes.CLINICALIMPRESSION;
5066        if ("ClinicalUseIssue".equals(codeString))
5067          return FHIRAllTypes.CLINICALUSEISSUE;
5068        if ("CodeSystem".equals(codeString))
5069          return FHIRAllTypes.CODESYSTEM;
5070        if ("Communication".equals(codeString))
5071          return FHIRAllTypes.COMMUNICATION;
5072        if ("CommunicationRequest".equals(codeString))
5073          return FHIRAllTypes.COMMUNICATIONREQUEST;
5074        if ("CompartmentDefinition".equals(codeString))
5075          return FHIRAllTypes.COMPARTMENTDEFINITION;
5076        if ("Composition".equals(codeString))
5077          return FHIRAllTypes.COMPOSITION;
5078        if ("ConceptMap".equals(codeString))
5079          return FHIRAllTypes.CONCEPTMAP;
5080        if ("Condition".equals(codeString))
5081          return FHIRAllTypes.CONDITION;
5082        if ("ConditionDefinition".equals(codeString))
5083          return FHIRAllTypes.CONDITIONDEFINITION;
5084        if ("Consent".equals(codeString))
5085          return FHIRAllTypes.CONSENT;
5086        if ("Contract".equals(codeString))
5087          return FHIRAllTypes.CONTRACT;
5088        if ("Coverage".equals(codeString))
5089          return FHIRAllTypes.COVERAGE;
5090        if ("CoverageEligibilityRequest".equals(codeString))
5091          return FHIRAllTypes.COVERAGEELIGIBILITYREQUEST;
5092        if ("CoverageEligibilityResponse".equals(codeString))
5093          return FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE;
5094        if ("DetectedIssue".equals(codeString))
5095          return FHIRAllTypes.DETECTEDISSUE;
5096        if ("Device".equals(codeString))
5097          return FHIRAllTypes.DEVICE;
5098        if ("DeviceDefinition".equals(codeString))
5099          return FHIRAllTypes.DEVICEDEFINITION;
5100        if ("DeviceMetric".equals(codeString))
5101          return FHIRAllTypes.DEVICEMETRIC;
5102        if ("DeviceRequest".equals(codeString))
5103          return FHIRAllTypes.DEVICEREQUEST;
5104        if ("DeviceUseStatement".equals(codeString))
5105          return FHIRAllTypes.DEVICEUSESTATEMENT;
5106        if ("DiagnosticReport".equals(codeString))
5107          return FHIRAllTypes.DIAGNOSTICREPORT;
5108        if ("DocumentManifest".equals(codeString))
5109          return FHIRAllTypes.DOCUMENTMANIFEST;
5110        if ("DocumentReference".equals(codeString))
5111          return FHIRAllTypes.DOCUMENTREFERENCE;
5112        if ("DomainResource".equals(codeString))
5113          return FHIRAllTypes.DOMAINRESOURCE;
5114        if ("Encounter".equals(codeString))
5115          return FHIRAllTypes.ENCOUNTER;
5116        if ("Endpoint".equals(codeString))
5117          return FHIRAllTypes.ENDPOINT;
5118        if ("EnrollmentRequest".equals(codeString))
5119          return FHIRAllTypes.ENROLLMENTREQUEST;
5120        if ("EnrollmentResponse".equals(codeString))
5121          return FHIRAllTypes.ENROLLMENTRESPONSE;
5122        if ("EpisodeOfCare".equals(codeString))
5123          return FHIRAllTypes.EPISODEOFCARE;
5124        if ("EventDefinition".equals(codeString))
5125          return FHIRAllTypes.EVENTDEFINITION;
5126        if ("Evidence".equals(codeString))
5127          return FHIRAllTypes.EVIDENCE;
5128        if ("EvidenceVariable".equals(codeString))
5129          return FHIRAllTypes.EVIDENCEVARIABLE;
5130        if ("ExampleScenario".equals(codeString))
5131          return FHIRAllTypes.EXAMPLESCENARIO;
5132        if ("ExplanationOfBenefit".equals(codeString))
5133          return FHIRAllTypes.EXPLANATIONOFBENEFIT;
5134        if ("FamilyMemberHistory".equals(codeString))
5135          return FHIRAllTypes.FAMILYMEMBERHISTORY;
5136        if ("Flag".equals(codeString))
5137          return FHIRAllTypes.FLAG;
5138        if ("Goal".equals(codeString))
5139          return FHIRAllTypes.GOAL;
5140        if ("GraphDefinition".equals(codeString))
5141          return FHIRAllTypes.GRAPHDEFINITION;
5142        if ("Group".equals(codeString))
5143          return FHIRAllTypes.GROUP;
5144        if ("GuidanceResponse".equals(codeString))
5145          return FHIRAllTypes.GUIDANCERESPONSE;
5146        if ("HealthcareService".equals(codeString))
5147          return FHIRAllTypes.HEALTHCARESERVICE;
5148        if ("ImagingStudy".equals(codeString))
5149          return FHIRAllTypes.IMAGINGSTUDY;
5150        if ("Immunization".equals(codeString))
5151          return FHIRAllTypes.IMMUNIZATION;
5152        if ("ImmunizationEvaluation".equals(codeString))
5153          return FHIRAllTypes.IMMUNIZATIONEVALUATION;
5154        if ("ImmunizationRecommendation".equals(codeString))
5155          return FHIRAllTypes.IMMUNIZATIONRECOMMENDATION;
5156        if ("ImplementationGuide".equals(codeString))
5157          return FHIRAllTypes.IMPLEMENTATIONGUIDE;
5158        if ("Ingredient".equals(codeString))
5159          return FHIRAllTypes.INGREDIENT;
5160        if ("InsurancePlan".equals(codeString))
5161          return FHIRAllTypes.INSURANCEPLAN;
5162        if ("Invoice".equals(codeString))
5163          return FHIRAllTypes.INVOICE;
5164        if ("Library".equals(codeString))
5165          return FHIRAllTypes.LIBRARY;
5166        if ("Linkage".equals(codeString))
5167          return FHIRAllTypes.LINKAGE;
5168        if ("List".equals(codeString))
5169          return FHIRAllTypes.LIST;
5170        if ("Location".equals(codeString))
5171          return FHIRAllTypes.LOCATION;
5172        if ("ManufacturedItemDefinition".equals(codeString))
5173          return FHIRAllTypes.MANUFACTUREDITEMDEFINITION;
5174        if ("Measure".equals(codeString))
5175          return FHIRAllTypes.MEASURE;
5176        if ("MeasureReport".equals(codeString))
5177          return FHIRAllTypes.MEASUREREPORT;
5178        if ("Medication".equals(codeString))
5179          return FHIRAllTypes.MEDICATION;
5180        if ("MedicationAdministration".equals(codeString))
5181          return FHIRAllTypes.MEDICATIONADMINISTRATION;
5182        if ("MedicationDispense".equals(codeString))
5183          return FHIRAllTypes.MEDICATIONDISPENSE;
5184        if ("MedicationKnowledge".equals(codeString))
5185          return FHIRAllTypes.MEDICATIONKNOWLEDGE;
5186        if ("MedicationRequest".equals(codeString))
5187          return FHIRAllTypes.MEDICATIONREQUEST;
5188        if ("MedicationUsage".equals(codeString))
5189          return FHIRAllTypes.MEDICATIONUSAGE;
5190        if ("MedicinalProductDefinition".equals(codeString))
5191          return FHIRAllTypes.MEDICINALPRODUCTDEFINITION;
5192        if ("MessageDefinition".equals(codeString))
5193          return FHIRAllTypes.MESSAGEDEFINITION;
5194        if ("MessageHeader".equals(codeString))
5195          return FHIRAllTypes.MESSAGEHEADER;
5196        if ("MolecularSequence".equals(codeString))
5197          return FHIRAllTypes.MOLECULARSEQUENCE;
5198        if ("NamingSystem".equals(codeString))
5199          return FHIRAllTypes.NAMINGSYSTEM;
5200        if ("NutritionIntake".equals(codeString))
5201          return FHIRAllTypes.NUTRITIONINTAKE;
5202        if ("NutritionOrder".equals(codeString))
5203          return FHIRAllTypes.NUTRITIONORDER;
5204        if ("Observation".equals(codeString))
5205          return FHIRAllTypes.OBSERVATION;
5206        if ("ObservationDefinition".equals(codeString))
5207          return FHIRAllTypes.OBSERVATIONDEFINITION;
5208        if ("OperationDefinition".equals(codeString))
5209          return FHIRAllTypes.OPERATIONDEFINITION;
5210        if ("OperationOutcome".equals(codeString))
5211          return FHIRAllTypes.OPERATIONOUTCOME;
5212        if ("Organization".equals(codeString))
5213          return FHIRAllTypes.ORGANIZATION;
5214        if ("OrganizationAffiliation".equals(codeString))
5215          return FHIRAllTypes.ORGANIZATIONAFFILIATION;
5216        if ("PackagedProductDefinition".equals(codeString))
5217          return FHIRAllTypes.PACKAGEDPRODUCTDEFINITION;
5218        if ("Parameters".equals(codeString))
5219          return FHIRAllTypes.PARAMETERS;
5220        if ("Patient".equals(codeString))
5221          return FHIRAllTypes.PATIENT;
5222        if ("PaymentNotice".equals(codeString))
5223          return FHIRAllTypes.PAYMENTNOTICE;
5224        if ("PaymentReconciliation".equals(codeString))
5225          return FHIRAllTypes.PAYMENTRECONCILIATION;
5226        if ("Person".equals(codeString))
5227          return FHIRAllTypes.PERSON;
5228        if ("PlanDefinition".equals(codeString))
5229          return FHIRAllTypes.PLANDEFINITION;
5230        if ("Practitioner".equals(codeString))
5231          return FHIRAllTypes.PRACTITIONER;
5232        if ("PractitionerRole".equals(codeString))
5233          return FHIRAllTypes.PRACTITIONERROLE;
5234        if ("Procedure".equals(codeString))
5235          return FHIRAllTypes.PROCEDURE;
5236        if ("Provenance".equals(codeString))
5237          return FHIRAllTypes.PROVENANCE;
5238        if ("Questionnaire".equals(codeString))
5239          return FHIRAllTypes.QUESTIONNAIRE;
5240        if ("QuestionnaireResponse".equals(codeString))
5241          return FHIRAllTypes.QUESTIONNAIRERESPONSE;
5242        if ("RegulatedAuthorization".equals(codeString))
5243          return FHIRAllTypes.REGULATEDAUTHORIZATION;
5244        if ("RelatedPerson".equals(codeString))
5245          return FHIRAllTypes.RELATEDPERSON;
5246        if ("RequestGroup".equals(codeString))
5247          return FHIRAllTypes.REQUESTGROUP;
5248        if ("ResearchStudy".equals(codeString))
5249          return FHIRAllTypes.RESEARCHSTUDY;
5250        if ("ResearchSubject".equals(codeString))
5251          return FHIRAllTypes.RESEARCHSUBJECT;
5252        if ("Resource".equals(codeString))
5253          return FHIRAllTypes.RESOURCE;
5254        if ("RiskAssessment".equals(codeString))
5255          return FHIRAllTypes.RISKASSESSMENT;
5256        if ("Schedule".equals(codeString))
5257          return FHIRAllTypes.SCHEDULE;
5258        if ("SearchParameter".equals(codeString))
5259          return FHIRAllTypes.SEARCHPARAMETER;
5260        if ("ServiceRequest".equals(codeString))
5261          return FHIRAllTypes.SERVICEREQUEST;
5262        if ("Slot".equals(codeString))
5263          return FHIRAllTypes.SLOT;
5264        if ("Specimen".equals(codeString))
5265          return FHIRAllTypes.SPECIMEN;
5266        if ("SpecimenDefinition".equals(codeString))
5267          return FHIRAllTypes.SPECIMENDEFINITION;
5268        if ("StructureDefinition".equals(codeString))
5269          return FHIRAllTypes.STRUCTUREDEFINITION;
5270        if ("StructureMap".equals(codeString))
5271          return FHIRAllTypes.STRUCTUREMAP;
5272        if ("Subscription".equals(codeString))
5273          return FHIRAllTypes.SUBSCRIPTION;
5274        if ("Substance".equals(codeString))
5275          return FHIRAllTypes.SUBSTANCE;
5276        if ("SubstanceDefinition".equals(codeString))
5277          return FHIRAllTypes.SUBSTANCEDEFINITION;
5278        if ("SubstanceNucleicAcid".equals(codeString))
5279          return FHIRAllTypes.SUBSTANCENUCLEICACID;
5280        if ("SubstancePolymer".equals(codeString))
5281          return FHIRAllTypes.SUBSTANCEPOLYMER;
5282        if ("SubstanceProtein".equals(codeString))
5283          return FHIRAllTypes.SUBSTANCEPROTEIN;
5284        if ("SubstanceReferenceInformation".equals(codeString))
5285          return FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION;
5286        if ("SubstanceSourceMaterial".equals(codeString))
5287          return FHIRAllTypes.SUBSTANCESOURCEMATERIAL;
5288        if ("SupplyDelivery".equals(codeString))
5289          return FHIRAllTypes.SUPPLYDELIVERY;
5290        if ("SupplyRequest".equals(codeString))
5291          return FHIRAllTypes.SUPPLYREQUEST;
5292        if ("Task".equals(codeString))
5293          return FHIRAllTypes.TASK;
5294        if ("TerminologyCapabilities".equals(codeString))
5295          return FHIRAllTypes.TERMINOLOGYCAPABILITIES;
5296        if ("TestReport".equals(codeString))
5297          return FHIRAllTypes.TESTREPORT;
5298        if ("TestScript".equals(codeString))
5299          return FHIRAllTypes.TESTSCRIPT;
5300        if ("Topic".equals(codeString))
5301          return FHIRAllTypes.TOPIC;
5302        if ("ValueSet".equals(codeString))
5303          return FHIRAllTypes.VALUESET;
5304        if ("VerificationResult".equals(codeString))
5305          return FHIRAllTypes.VERIFICATIONRESULT;
5306        if ("VisionPrescription".equals(codeString))
5307          return FHIRAllTypes.VISIONPRESCRIPTION;
5308        if ("Type".equals(codeString))
5309          return FHIRAllTypes.TYPE;
5310        if ("Any".equals(codeString))
5311          return FHIRAllTypes.ANY;
5312        throw new IllegalArgumentException("Unknown FHIRAllTypes code '"+codeString+"'");
5313        }
5314        public Enumeration<FHIRAllTypes> fromType(Base code) throws FHIRException {
5315          if (code == null)
5316            return null;
5317          if (code.isEmpty())
5318            return new Enumeration<FHIRAllTypes>(this);
5319          String codeString = ((PrimitiveType) code).asStringValue();
5320          if (codeString == null || "".equals(codeString))
5321            return null;
5322        if ("Address".equals(codeString))
5323          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADDRESS);
5324        if ("Age".equals(codeString))
5325          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AGE);
5326        if ("Annotation".equals(codeString))
5327          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANNOTATION);
5328        if ("Attachment".equals(codeString))
5329          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ATTACHMENT);
5330        if ("BackboneElement".equals(codeString))
5331          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BACKBONEELEMENT);
5332        if ("BackboneType".equals(codeString))
5333          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BACKBONETYPE);
5334        if ("Base".equals(codeString))
5335          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASE);
5336        if ("CodeableConcept".equals(codeString))
5337          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODEABLECONCEPT);
5338        if ("CodeableReference".equals(codeString))
5339          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODEABLEREFERENCE);
5340        if ("Coding".equals(codeString))
5341          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODING);
5342        if ("ContactDetail".equals(codeString))
5343          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTDETAIL);
5344        if ("ContactPoint".equals(codeString))
5345          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTPOINT);
5346        if ("Contributor".equals(codeString))
5347          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRIBUTOR);
5348        if ("Count".equals(codeString))
5349          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COUNT);
5350        if ("DataRequirement".equals(codeString))
5351          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATAREQUIREMENT);
5352        if ("DataType".equals(codeString))
5353          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATATYPE);
5354        if ("Distance".equals(codeString))
5355          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DISTANCE);
5356        if ("Dosage".equals(codeString))
5357          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOSAGE);
5358        if ("Duration".equals(codeString))
5359          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DURATION);
5360        if ("Element".equals(codeString))
5361          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENT);
5362        if ("ElementDefinition".equals(codeString))
5363          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENTDEFINITION);
5364        if ("Expression".equals(codeString))
5365          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPRESSION);
5366        if ("Extension".equals(codeString))
5367          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXTENSION);
5368        if ("HumanName".equals(codeString))
5369          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HUMANNAME);
5370        if ("Identifier".equals(codeString))
5371          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IDENTIFIER);
5372        if ("MarketingStatus".equals(codeString))
5373          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKETINGSTATUS);
5374        if ("Meta".equals(codeString))
5375          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.META);
5376        if ("Money".equals(codeString))
5377          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEY);
5378        if ("MoneyQuantity".equals(codeString))
5379          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEYQUANTITY);
5380        if ("Narrative".equals(codeString))
5381          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NARRATIVE);
5382        if ("OrderedDistribution".equals(codeString))
5383          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORDEREDDISTRIBUTION);
5384        if ("ParameterDefinition".equals(codeString))
5385          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERDEFINITION);
5386        if ("Period".equals(codeString))
5387          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERIOD);
5388        if ("Population".equals(codeString))
5389          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POPULATION);
5390        if ("PrimitiveType".equals(codeString))
5391          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRIMITIVETYPE);
5392        if ("ProdCharacteristic".equals(codeString))
5393          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODCHARACTERISTIC);
5394        if ("ProductShelfLife".equals(codeString))
5395          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODUCTSHELFLIFE);
5396        if ("Quantity".equals(codeString))
5397          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUANTITY);
5398        if ("Range".equals(codeString))
5399          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RANGE);
5400        if ("Ratio".equals(codeString))
5401          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RATIO);
5402        if ("Reference".equals(codeString))
5403          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REFERENCE);
5404        if ("RelatedArtifact".equals(codeString))
5405          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDARTIFACT);
5406        if ("SampledData".equals(codeString))
5407          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SAMPLEDDATA);
5408        if ("Signature".equals(codeString))
5409          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIGNATURE);
5410        if ("SimpleQuantity".equals(codeString))
5411          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIMPLEQUANTITY);
5412        if ("Statistic".equals(codeString))
5413          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STATISTIC);
5414        if ("SubstanceAmount".equals(codeString))
5415          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEAMOUNT);
5416        if ("Timing".equals(codeString))
5417          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIMING);
5418        if ("TriggerDefinition".equals(codeString))
5419          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TRIGGERDEFINITION);
5420        if ("UsageContext".equals(codeString))
5421          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.USAGECONTEXT);
5422        if ("base64Binary".equals(codeString))
5423          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASE64BINARY);
5424        if ("boolean".equals(codeString))
5425          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BOOLEAN);
5426        if ("canonical".equals(codeString))
5427          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CANONICAL);
5428        if ("code".equals(codeString))
5429          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODE);
5430        if ("date".equals(codeString))
5431          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATE);
5432        if ("dateTime".equals(codeString))
5433          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATETIME);
5434        if ("decimal".equals(codeString))
5435          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DECIMAL);
5436        if ("id".equals(codeString))
5437          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ID);
5438        if ("instant".equals(codeString))
5439          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSTANT);
5440        if ("integer".equals(codeString))
5441          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INTEGER);
5442        if ("integer64".equals(codeString))
5443          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INTEGER64);
5444        if ("markdown".equals(codeString))
5445          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKDOWN);
5446        if ("oid".equals(codeString))
5447          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OID);
5448        if ("positiveInt".equals(codeString))
5449          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POSITIVEINT);
5450        if ("string".equals(codeString))
5451          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRING);
5452        if ("time".equals(codeString))
5453          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIME);
5454        if ("unsignedInt".equals(codeString))
5455          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UNSIGNEDINT);
5456        if ("uri".equals(codeString))
5457          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URI);
5458        if ("url".equals(codeString))
5459          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URL);
5460        if ("uuid".equals(codeString))
5461          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UUID);
5462        if ("xhtml".equals(codeString))
5463          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.XHTML);
5464        if ("Account".equals(codeString))
5465          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACCOUNT);
5466        if ("ActivityDefinition".equals(codeString))
5467          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACTIVITYDEFINITION);
5468        if ("AdministrableProductDefinition".equals(codeString))
5469          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION);
5470        if ("AdverseEvent".equals(codeString))
5471          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADVERSEEVENT);
5472        if ("AllergyIntolerance".equals(codeString))
5473          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ALLERGYINTOLERANCE);
5474        if ("Appointment".equals(codeString))
5475          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENT);
5476        if ("AppointmentResponse".equals(codeString))
5477          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENTRESPONSE);
5478        if ("AuditEvent".equals(codeString))
5479          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AUDITEVENT);
5480        if ("Basic".equals(codeString))
5481          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASIC);
5482        if ("Binary".equals(codeString))
5483          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BINARY);
5484        if ("BiologicallyDerivedProduct".equals(codeString))
5485          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT);
5486        if ("BodyStructure".equals(codeString))
5487          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BODYSTRUCTURE);
5488        if ("Bundle".equals(codeString))
5489          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BUNDLE);
5490        if ("CapabilityStatement".equals(codeString))
5491          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAPABILITYSTATEMENT);
5492        if ("CapabilityStatement2".equals(codeString))
5493          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAPABILITYSTATEMENT2);
5494        if ("CarePlan".equals(codeString))
5495          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAREPLAN);
5496        if ("CareTeam".equals(codeString))
5497          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CARETEAM);
5498        if ("CatalogEntry".equals(codeString))
5499          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CATALOGENTRY);
5500        if ("ChargeItem".equals(codeString))
5501          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEM);
5502        if ("ChargeItemDefinition".equals(codeString))
5503          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEMDEFINITION);
5504        if ("Claim".equals(codeString))
5505          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIM);
5506        if ("ClaimResponse".equals(codeString))
5507          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIMRESPONSE);
5508        if ("ClinicalImpression".equals(codeString))
5509          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLINICALIMPRESSION);
5510        if ("ClinicalUseIssue".equals(codeString))
5511          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLINICALUSEISSUE);
5512        if ("CodeSystem".equals(codeString))
5513          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODESYSTEM);
5514        if ("Communication".equals(codeString))
5515          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATION);
5516        if ("CommunicationRequest".equals(codeString))
5517          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATIONREQUEST);
5518        if ("CompartmentDefinition".equals(codeString))
5519          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPARTMENTDEFINITION);
5520        if ("Composition".equals(codeString))
5521          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPOSITION);
5522        if ("ConceptMap".equals(codeString))
5523          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONCEPTMAP);
5524        if ("Condition".equals(codeString))
5525          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONDITION);
5526        if ("ConditionDefinition".equals(codeString))
5527          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONDITIONDEFINITION);
5528        if ("Consent".equals(codeString))
5529          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONSENT);
5530        if ("Contract".equals(codeString))
5531          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRACT);
5532        if ("Coverage".equals(codeString))
5533          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGE);
5534        if ("CoverageEligibilityRequest".equals(codeString))
5535          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYREQUEST);
5536        if ("CoverageEligibilityResponse".equals(codeString))
5537          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE);
5538        if ("DetectedIssue".equals(codeString))
5539          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DETECTEDISSUE);
5540        if ("Device".equals(codeString))
5541          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICE);
5542        if ("DeviceDefinition".equals(codeString))
5543          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEDEFINITION);
5544        if ("DeviceMetric".equals(codeString))
5545          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEMETRIC);
5546        if ("DeviceRequest".equals(codeString))
5547          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEREQUEST);
5548        if ("DeviceUseStatement".equals(codeString))
5549          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEUSESTATEMENT);
5550        if ("DiagnosticReport".equals(codeString))
5551          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DIAGNOSTICREPORT);
5552        if ("DocumentManifest".equals(codeString))
5553          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTMANIFEST);
5554        if ("DocumentReference".equals(codeString))
5555          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTREFERENCE);
5556        if ("DomainResource".equals(codeString))
5557          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOMAINRESOURCE);
5558        if ("Encounter".equals(codeString))
5559          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENCOUNTER);
5560        if ("Endpoint".equals(codeString))
5561          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENDPOINT);
5562        if ("EnrollmentRequest".equals(codeString))
5563          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTREQUEST);
5564        if ("EnrollmentResponse".equals(codeString))
5565          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTRESPONSE);
5566        if ("EpisodeOfCare".equals(codeString))
5567          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EPISODEOFCARE);
5568        if ("EventDefinition".equals(codeString))
5569          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVENTDEFINITION);
5570        if ("Evidence".equals(codeString))
5571          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCE);
5572        if ("EvidenceVariable".equals(codeString))
5573          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCEVARIABLE);
5574        if ("ExampleScenario".equals(codeString))
5575          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXAMPLESCENARIO);
5576        if ("ExplanationOfBenefit".equals(codeString))
5577          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPLANATIONOFBENEFIT);
5578        if ("FamilyMemberHistory".equals(codeString))
5579          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FAMILYMEMBERHISTORY);
5580        if ("Flag".equals(codeString))
5581          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FLAG);
5582        if ("Goal".equals(codeString))
5583          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GOAL);
5584        if ("GraphDefinition".equals(codeString))
5585          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GRAPHDEFINITION);
5586        if ("Group".equals(codeString))
5587          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GROUP);
5588        if ("GuidanceResponse".equals(codeString))
5589          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GUIDANCERESPONSE);
5590        if ("HealthcareService".equals(codeString))
5591          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HEALTHCARESERVICE);
5592        if ("ImagingStudy".equals(codeString))
5593          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMAGINGSTUDY);
5594        if ("Immunization".equals(codeString))
5595          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATION);
5596        if ("ImmunizationEvaluation".equals(codeString))
5597          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONEVALUATION);
5598        if ("ImmunizationRecommendation".equals(codeString))
5599          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONRECOMMENDATION);
5600        if ("ImplementationGuide".equals(codeString))
5601          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMPLEMENTATIONGUIDE);
5602        if ("Ingredient".equals(codeString))
5603          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INGREDIENT);
5604        if ("InsurancePlan".equals(codeString))
5605          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSURANCEPLAN);
5606        if ("Invoice".equals(codeString))
5607          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INVOICE);
5608        if ("Library".equals(codeString))
5609          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIBRARY);
5610        if ("Linkage".equals(codeString))
5611          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LINKAGE);
5612        if ("List".equals(codeString))
5613          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIST);
5614        if ("Location".equals(codeString))
5615          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LOCATION);
5616        if ("ManufacturedItemDefinition".equals(codeString))
5617          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MANUFACTUREDITEMDEFINITION);
5618        if ("Measure".equals(codeString))
5619          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASURE);
5620        if ("MeasureReport".equals(codeString))
5621          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASUREREPORT);
5622        if ("Medication".equals(codeString))
5623          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATION);
5624        if ("MedicationAdministration".equals(codeString))
5625          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONADMINISTRATION);
5626        if ("MedicationDispense".equals(codeString))
5627          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONDISPENSE);
5628        if ("MedicationKnowledge".equals(codeString))
5629          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONKNOWLEDGE);
5630        if ("MedicationRequest".equals(codeString))
5631          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONREQUEST);
5632        if ("MedicationUsage".equals(codeString))
5633          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONUSAGE);
5634        if ("MedicinalProductDefinition".equals(codeString))
5635          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTDEFINITION);
5636        if ("MessageDefinition".equals(codeString))
5637          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEDEFINITION);
5638        if ("MessageHeader".equals(codeString))
5639          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEHEADER);
5640        if ("MolecularSequence".equals(codeString))
5641          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MOLECULARSEQUENCE);
5642        if ("NamingSystem".equals(codeString))
5643          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NAMINGSYSTEM);
5644        if ("NutritionIntake".equals(codeString))
5645          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NUTRITIONINTAKE);
5646        if ("NutritionOrder".equals(codeString))
5647          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NUTRITIONORDER);
5648        if ("Observation".equals(codeString))
5649          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATION);
5650        if ("ObservationDefinition".equals(codeString))
5651          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATIONDEFINITION);
5652        if ("OperationDefinition".equals(codeString))
5653          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONDEFINITION);
5654        if ("OperationOutcome".equals(codeString))
5655          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONOUTCOME);
5656        if ("Organization".equals(codeString))
5657          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATION);
5658        if ("OrganizationAffiliation".equals(codeString))
5659          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATIONAFFILIATION);
5660        if ("PackagedProductDefinition".equals(codeString))
5661          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PACKAGEDPRODUCTDEFINITION);
5662        if ("Parameters".equals(codeString))
5663          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERS);
5664        if ("Patient".equals(codeString))
5665          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PATIENT);
5666        if ("PaymentNotice".equals(codeString))
5667          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTNOTICE);
5668        if ("PaymentReconciliation".equals(codeString))
5669          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTRECONCILIATION);
5670        if ("Person".equals(codeString))
5671          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERSON);
5672        if ("PlanDefinition".equals(codeString))
5673          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PLANDEFINITION);
5674        if ("Practitioner".equals(codeString))
5675          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONER);
5676        if ("PractitionerRole".equals(codeString))
5677          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONERROLE);
5678        if ("Procedure".equals(codeString))
5679          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROCEDURE);
5680        if ("Provenance".equals(codeString))
5681          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROVENANCE);
5682        if ("Questionnaire".equals(codeString))
5683          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRE);
5684        if ("QuestionnaireResponse".equals(codeString))
5685          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRERESPONSE);
5686        if ("RegulatedAuthorization".equals(codeString))
5687          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REGULATEDAUTHORIZATION);
5688        if ("RelatedPerson".equals(codeString))
5689          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDPERSON);
5690        if ("RequestGroup".equals(codeString))
5691          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REQUESTGROUP);
5692        if ("ResearchStudy".equals(codeString))
5693          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSTUDY);
5694        if ("ResearchSubject".equals(codeString))
5695          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSUBJECT);
5696        if ("Resource".equals(codeString))
5697          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESOURCE);
5698        if ("RiskAssessment".equals(codeString))
5699          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RISKASSESSMENT);
5700        if ("Schedule".equals(codeString))
5701          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SCHEDULE);
5702        if ("SearchParameter".equals(codeString))
5703          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SEARCHPARAMETER);
5704        if ("ServiceRequest".equals(codeString))
5705          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SERVICEREQUEST);
5706        if ("Slot".equals(codeString))
5707          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SLOT);
5708        if ("Specimen".equals(codeString))
5709          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMEN);
5710        if ("SpecimenDefinition".equals(codeString))
5711          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMENDEFINITION);
5712        if ("StructureDefinition".equals(codeString))
5713          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREDEFINITION);
5714        if ("StructureMap".equals(codeString))
5715          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREMAP);
5716        if ("Subscription".equals(codeString))
5717          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSCRIPTION);
5718        if ("Substance".equals(codeString))
5719          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCE);
5720        if ("SubstanceDefinition".equals(codeString))
5721          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEDEFINITION);
5722        if ("SubstanceNucleicAcid".equals(codeString))
5723          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCENUCLEICACID);
5724        if ("SubstancePolymer".equals(codeString))
5725          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPOLYMER);
5726        if ("SubstanceProtein".equals(codeString))
5727          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPROTEIN);
5728        if ("SubstanceReferenceInformation".equals(codeString))
5729          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION);
5730        if ("SubstanceSourceMaterial".equals(codeString))
5731          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCESOURCEMATERIAL);
5732        if ("SupplyDelivery".equals(codeString))
5733          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYDELIVERY);
5734        if ("SupplyRequest".equals(codeString))
5735          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYREQUEST);
5736        if ("Task".equals(codeString))
5737          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TASK);
5738        if ("TerminologyCapabilities".equals(codeString))
5739          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TERMINOLOGYCAPABILITIES);
5740        if ("TestReport".equals(codeString))
5741          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTREPORT);
5742        if ("TestScript".equals(codeString))
5743          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTSCRIPT);
5744        if ("Topic".equals(codeString))
5745          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TOPIC);
5746        if ("ValueSet".equals(codeString))
5747          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VALUESET);
5748        if ("VerificationResult".equals(codeString))
5749          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VERIFICATIONRESULT);
5750        if ("VisionPrescription".equals(codeString))
5751          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VISIONPRESCRIPTION);
5752        if ("Type".equals(codeString))
5753          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TYPE);
5754        if ("Any".equals(codeString))
5755          return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANY);
5756        throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'");
5757        }
5758    public String toCode(FHIRAllTypes code) {
5759      if (code == FHIRAllTypes.ADDRESS)
5760        return "Address";
5761      if (code == FHIRAllTypes.AGE)
5762        return "Age";
5763      if (code == FHIRAllTypes.ANNOTATION)
5764        return "Annotation";
5765      if (code == FHIRAllTypes.ATTACHMENT)
5766        return "Attachment";
5767      if (code == FHIRAllTypes.BACKBONEELEMENT)
5768        return "BackboneElement";
5769      if (code == FHIRAllTypes.BACKBONETYPE)
5770        return "BackboneType";
5771      if (code == FHIRAllTypes.BASE)
5772        return "Base";
5773      if (code == FHIRAllTypes.CODEABLECONCEPT)
5774        return "CodeableConcept";
5775      if (code == FHIRAllTypes.CODEABLEREFERENCE)
5776        return "CodeableReference";
5777      if (code == FHIRAllTypes.CODING)
5778        return "Coding";
5779      if (code == FHIRAllTypes.CONTACTDETAIL)
5780        return "ContactDetail";
5781      if (code == FHIRAllTypes.CONTACTPOINT)
5782        return "ContactPoint";
5783      if (code == FHIRAllTypes.CONTRIBUTOR)
5784        return "Contributor";
5785      if (code == FHIRAllTypes.COUNT)
5786        return "Count";
5787      if (code == FHIRAllTypes.DATAREQUIREMENT)
5788        return "DataRequirement";
5789      if (code == FHIRAllTypes.DATATYPE)
5790        return "DataType";
5791      if (code == FHIRAllTypes.DISTANCE)
5792        return "Distance";
5793      if (code == FHIRAllTypes.DOSAGE)
5794        return "Dosage";
5795      if (code == FHIRAllTypes.DURATION)
5796        return "Duration";
5797      if (code == FHIRAllTypes.ELEMENT)
5798        return "Element";
5799      if (code == FHIRAllTypes.ELEMENTDEFINITION)
5800        return "ElementDefinition";
5801      if (code == FHIRAllTypes.EXPRESSION)
5802        return "Expression";
5803      if (code == FHIRAllTypes.EXTENSION)
5804        return "Extension";
5805      if (code == FHIRAllTypes.HUMANNAME)
5806        return "HumanName";
5807      if (code == FHIRAllTypes.IDENTIFIER)
5808        return "Identifier";
5809      if (code == FHIRAllTypes.MARKETINGSTATUS)
5810        return "MarketingStatus";
5811      if (code == FHIRAllTypes.META)
5812        return "Meta";
5813      if (code == FHIRAllTypes.MONEY)
5814        return "Money";
5815      if (code == FHIRAllTypes.MONEYQUANTITY)
5816        return "MoneyQuantity";
5817      if (code == FHIRAllTypes.NARRATIVE)
5818        return "Narrative";
5819      if (code == FHIRAllTypes.ORDEREDDISTRIBUTION)
5820        return "OrderedDistribution";
5821      if (code == FHIRAllTypes.PARAMETERDEFINITION)
5822        return "ParameterDefinition";
5823      if (code == FHIRAllTypes.PERIOD)
5824        return "Period";
5825      if (code == FHIRAllTypes.POPULATION)
5826        return "Population";
5827      if (code == FHIRAllTypes.PRIMITIVETYPE)
5828        return "PrimitiveType";
5829      if (code == FHIRAllTypes.PRODCHARACTERISTIC)
5830        return "ProdCharacteristic";
5831      if (code == FHIRAllTypes.PRODUCTSHELFLIFE)
5832        return "ProductShelfLife";
5833      if (code == FHIRAllTypes.QUANTITY)
5834        return "Quantity";
5835      if (code == FHIRAllTypes.RANGE)
5836        return "Range";
5837      if (code == FHIRAllTypes.RATIO)
5838        return "Ratio";
5839      if (code == FHIRAllTypes.REFERENCE)
5840        return "Reference";
5841      if (code == FHIRAllTypes.RELATEDARTIFACT)
5842        return "RelatedArtifact";
5843      if (code == FHIRAllTypes.SAMPLEDDATA)
5844        return "SampledData";
5845      if (code == FHIRAllTypes.SIGNATURE)
5846        return "Signature";
5847      if (code == FHIRAllTypes.SIMPLEQUANTITY)
5848        return "SimpleQuantity";
5849      if (code == FHIRAllTypes.STATISTIC)
5850        return "Statistic";
5851      if (code == FHIRAllTypes.SUBSTANCEAMOUNT)
5852        return "SubstanceAmount";
5853      if (code == FHIRAllTypes.TIMING)
5854        return "Timing";
5855      if (code == FHIRAllTypes.TRIGGERDEFINITION)
5856        return "TriggerDefinition";
5857      if (code == FHIRAllTypes.USAGECONTEXT)
5858        return "UsageContext";
5859      if (code == FHIRAllTypes.BASE64BINARY)
5860        return "base64Binary";
5861      if (code == FHIRAllTypes.BOOLEAN)
5862        return "boolean";
5863      if (code == FHIRAllTypes.CANONICAL)
5864        return "canonical";
5865      if (code == FHIRAllTypes.CODE)
5866        return "code";
5867      if (code == FHIRAllTypes.DATE)
5868        return "date";
5869      if (code == FHIRAllTypes.DATETIME)
5870        return "dateTime";
5871      if (code == FHIRAllTypes.DECIMAL)
5872        return "decimal";
5873      if (code == FHIRAllTypes.ID)
5874        return "id";
5875      if (code == FHIRAllTypes.INSTANT)
5876        return "instant";
5877      if (code == FHIRAllTypes.INTEGER)
5878        return "integer";
5879      if (code == FHIRAllTypes.INTEGER64)
5880        return "integer64";
5881      if (code == FHIRAllTypes.MARKDOWN)
5882        return "markdown";
5883      if (code == FHIRAllTypes.OID)
5884        return "oid";
5885      if (code == FHIRAllTypes.POSITIVEINT)
5886        return "positiveInt";
5887      if (code == FHIRAllTypes.STRING)
5888        return "string";
5889      if (code == FHIRAllTypes.TIME)
5890        return "time";
5891      if (code == FHIRAllTypes.UNSIGNEDINT)
5892        return "unsignedInt";
5893      if (code == FHIRAllTypes.URI)
5894        return "uri";
5895      if (code == FHIRAllTypes.URL)
5896        return "url";
5897      if (code == FHIRAllTypes.UUID)
5898        return "uuid";
5899      if (code == FHIRAllTypes.XHTML)
5900        return "xhtml";
5901      if (code == FHIRAllTypes.ACCOUNT)
5902        return "Account";
5903      if (code == FHIRAllTypes.ACTIVITYDEFINITION)
5904        return "ActivityDefinition";
5905      if (code == FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION)
5906        return "AdministrableProductDefinition";
5907      if (code == FHIRAllTypes.ADVERSEEVENT)
5908        return "AdverseEvent";
5909      if (code == FHIRAllTypes.ALLERGYINTOLERANCE)
5910        return "AllergyIntolerance";
5911      if (code == FHIRAllTypes.APPOINTMENT)
5912        return "Appointment";
5913      if (code == FHIRAllTypes.APPOINTMENTRESPONSE)
5914        return "AppointmentResponse";
5915      if (code == FHIRAllTypes.AUDITEVENT)
5916        return "AuditEvent";
5917      if (code == FHIRAllTypes.BASIC)
5918        return "Basic";
5919      if (code == FHIRAllTypes.BINARY)
5920        return "Binary";
5921      if (code == FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT)
5922        return "BiologicallyDerivedProduct";
5923      if (code == FHIRAllTypes.BODYSTRUCTURE)
5924        return "BodyStructure";
5925      if (code == FHIRAllTypes.BUNDLE)
5926        return "Bundle";
5927      if (code == FHIRAllTypes.CAPABILITYSTATEMENT)
5928        return "CapabilityStatement";
5929      if (code == FHIRAllTypes.CAPABILITYSTATEMENT2)
5930        return "CapabilityStatement2";
5931      if (code == FHIRAllTypes.CAREPLAN)
5932        return "CarePlan";
5933      if (code == FHIRAllTypes.CARETEAM)
5934        return "CareTeam";
5935      if (code == FHIRAllTypes.CATALOGENTRY)
5936        return "CatalogEntry";
5937      if (code == FHIRAllTypes.CHARGEITEM)
5938        return "ChargeItem";
5939      if (code == FHIRAllTypes.CHARGEITEMDEFINITION)
5940        return "ChargeItemDefinition";
5941      if (code == FHIRAllTypes.CLAIM)
5942        return "Claim";
5943      if (code == FHIRAllTypes.CLAIMRESPONSE)
5944        return "ClaimResponse";
5945      if (code == FHIRAllTypes.CLINICALIMPRESSION)
5946        return "ClinicalImpression";
5947      if (code == FHIRAllTypes.CLINICALUSEISSUE)
5948        return "ClinicalUseIssue";
5949      if (code == FHIRAllTypes.CODESYSTEM)
5950        return "CodeSystem";
5951      if (code == FHIRAllTypes.COMMUNICATION)
5952        return "Communication";
5953      if (code == FHIRAllTypes.COMMUNICATIONREQUEST)
5954        return "CommunicationRequest";
5955      if (code == FHIRAllTypes.COMPARTMENTDEFINITION)
5956        return "CompartmentDefinition";
5957      if (code == FHIRAllTypes.COMPOSITION)
5958        return "Composition";
5959      if (code == FHIRAllTypes.CONCEPTMAP)
5960        return "ConceptMap";
5961      if (code == FHIRAllTypes.CONDITION)
5962        return "Condition";
5963      if (code == FHIRAllTypes.CONDITIONDEFINITION)
5964        return "ConditionDefinition";
5965      if (code == FHIRAllTypes.CONSENT)
5966        return "Consent";
5967      if (code == FHIRAllTypes.CONTRACT)
5968        return "Contract";
5969      if (code == FHIRAllTypes.COVERAGE)
5970        return "Coverage";
5971      if (code == FHIRAllTypes.COVERAGEELIGIBILITYREQUEST)
5972        return "CoverageEligibilityRequest";
5973      if (code == FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE)
5974        return "CoverageEligibilityResponse";
5975      if (code == FHIRAllTypes.DETECTEDISSUE)
5976        return "DetectedIssue";
5977      if (code == FHIRAllTypes.DEVICE)
5978        return "Device";
5979      if (code == FHIRAllTypes.DEVICEDEFINITION)
5980        return "DeviceDefinition";
5981      if (code == FHIRAllTypes.DEVICEMETRIC)
5982        return "DeviceMetric";
5983      if (code == FHIRAllTypes.DEVICEREQUEST)
5984        return "DeviceRequest";
5985      if (code == FHIRAllTypes.DEVICEUSESTATEMENT)
5986        return "DeviceUseStatement";
5987      if (code == FHIRAllTypes.DIAGNOSTICREPORT)
5988        return "DiagnosticReport";
5989      if (code == FHIRAllTypes.DOCUMENTMANIFEST)
5990        return "DocumentManifest";
5991      if (code == FHIRAllTypes.DOCUMENTREFERENCE)
5992        return "DocumentReference";
5993      if (code == FHIRAllTypes.DOMAINRESOURCE)
5994        return "DomainResource";
5995      if (code == FHIRAllTypes.ENCOUNTER)
5996        return "Encounter";
5997      if (code == FHIRAllTypes.ENDPOINT)
5998        return "Endpoint";
5999      if (code == FHIRAllTypes.ENROLLMENTREQUEST)
6000        return "EnrollmentRequest";
6001      if (code == FHIRAllTypes.ENROLLMENTRESPONSE)
6002        return "EnrollmentResponse";
6003      if (code == FHIRAllTypes.EPISODEOFCARE)
6004        return "EpisodeOfCare";
6005      if (code == FHIRAllTypes.EVENTDEFINITION)
6006        return "EventDefinition";
6007      if (code == FHIRAllTypes.EVIDENCE)
6008        return "Evidence";
6009      if (code == FHIRAllTypes.EVIDENCEVARIABLE)
6010        return "EvidenceVariable";
6011      if (code == FHIRAllTypes.EXAMPLESCENARIO)
6012        return "ExampleScenario";
6013      if (code == FHIRAllTypes.EXPLANATIONOFBENEFIT)
6014        return "ExplanationOfBenefit";
6015      if (code == FHIRAllTypes.FAMILYMEMBERHISTORY)
6016        return "FamilyMemberHistory";
6017      if (code == FHIRAllTypes.FLAG)
6018        return "Flag";
6019      if (code == FHIRAllTypes.GOAL)
6020        return "Goal";
6021      if (code == FHIRAllTypes.GRAPHDEFINITION)
6022        return "GraphDefinition";
6023      if (code == FHIRAllTypes.GROUP)
6024        return "Group";
6025      if (code == FHIRAllTypes.GUIDANCERESPONSE)
6026        return "GuidanceResponse";
6027      if (code == FHIRAllTypes.HEALTHCARESERVICE)
6028        return "HealthcareService";
6029      if (code == FHIRAllTypes.IMAGINGSTUDY)
6030        return "ImagingStudy";
6031      if (code == FHIRAllTypes.IMMUNIZATION)
6032        return "Immunization";
6033      if (code == FHIRAllTypes.IMMUNIZATIONEVALUATION)
6034        return "ImmunizationEvaluation";
6035      if (code == FHIRAllTypes.IMMUNIZATIONRECOMMENDATION)
6036        return "ImmunizationRecommendation";
6037      if (code == FHIRAllTypes.IMPLEMENTATIONGUIDE)
6038        return "ImplementationGuide";
6039      if (code == FHIRAllTypes.INGREDIENT)
6040        return "Ingredient";
6041      if (code == FHIRAllTypes.INSURANCEPLAN)
6042        return "InsurancePlan";
6043      if (code == FHIRAllTypes.INVOICE)
6044        return "Invoice";
6045      if (code == FHIRAllTypes.LIBRARY)
6046        return "Library";
6047      if (code == FHIRAllTypes.LINKAGE)
6048        return "Linkage";
6049      if (code == FHIRAllTypes.LIST)
6050        return "List";
6051      if (code == FHIRAllTypes.LOCATION)
6052        return "Location";
6053      if (code == FHIRAllTypes.MANUFACTUREDITEMDEFINITION)
6054        return "ManufacturedItemDefinition";
6055      if (code == FHIRAllTypes.MEASURE)
6056        return "Measure";
6057      if (code == FHIRAllTypes.MEASUREREPORT)
6058        return "MeasureReport";
6059      if (code == FHIRAllTypes.MEDICATION)
6060        return "Medication";
6061      if (code == FHIRAllTypes.MEDICATIONADMINISTRATION)
6062        return "MedicationAdministration";
6063      if (code == FHIRAllTypes.MEDICATIONDISPENSE)
6064        return "MedicationDispense";
6065      if (code == FHIRAllTypes.MEDICATIONKNOWLEDGE)
6066        return "MedicationKnowledge";
6067      if (code == FHIRAllTypes.MEDICATIONREQUEST)
6068        return "MedicationRequest";
6069      if (code == FHIRAllTypes.MEDICATIONUSAGE)
6070        return "MedicationUsage";
6071      if (code == FHIRAllTypes.MEDICINALPRODUCTDEFINITION)
6072        return "MedicinalProductDefinition";
6073      if (code == FHIRAllTypes.MESSAGEDEFINITION)
6074        return "MessageDefinition";
6075      if (code == FHIRAllTypes.MESSAGEHEADER)
6076        return "MessageHeader";
6077      if (code == FHIRAllTypes.MOLECULARSEQUENCE)
6078        return "MolecularSequence";
6079      if (code == FHIRAllTypes.NAMINGSYSTEM)
6080        return "NamingSystem";
6081      if (code == FHIRAllTypes.NUTRITIONINTAKE)
6082        return "NutritionIntake";
6083      if (code == FHIRAllTypes.NUTRITIONORDER)
6084        return "NutritionOrder";
6085      if (code == FHIRAllTypes.OBSERVATION)
6086        return "Observation";
6087      if (code == FHIRAllTypes.OBSERVATIONDEFINITION)
6088        return "ObservationDefinition";
6089      if (code == FHIRAllTypes.OPERATIONDEFINITION)
6090        return "OperationDefinition";
6091      if (code == FHIRAllTypes.OPERATIONOUTCOME)
6092        return "OperationOutcome";
6093      if (code == FHIRAllTypes.ORGANIZATION)
6094        return "Organization";
6095      if (code == FHIRAllTypes.ORGANIZATIONAFFILIATION)
6096        return "OrganizationAffiliation";
6097      if (code == FHIRAllTypes.PACKAGEDPRODUCTDEFINITION)
6098        return "PackagedProductDefinition";
6099      if (code == FHIRAllTypes.PARAMETERS)
6100        return "Parameters";
6101      if (code == FHIRAllTypes.PATIENT)
6102        return "Patient";
6103      if (code == FHIRAllTypes.PAYMENTNOTICE)
6104        return "PaymentNotice";
6105      if (code == FHIRAllTypes.PAYMENTRECONCILIATION)
6106        return "PaymentReconciliation";
6107      if (code == FHIRAllTypes.PERSON)
6108        return "Person";
6109      if (code == FHIRAllTypes.PLANDEFINITION)
6110        return "PlanDefinition";
6111      if (code == FHIRAllTypes.PRACTITIONER)
6112        return "Practitioner";
6113      if (code == FHIRAllTypes.PRACTITIONERROLE)
6114        return "PractitionerRole";
6115      if (code == FHIRAllTypes.PROCEDURE)
6116        return "Procedure";
6117      if (code == FHIRAllTypes.PROVENANCE)
6118        return "Provenance";
6119      if (code == FHIRAllTypes.QUESTIONNAIRE)
6120        return "Questionnaire";
6121      if (code == FHIRAllTypes.QUESTIONNAIRERESPONSE)
6122        return "QuestionnaireResponse";
6123      if (code == FHIRAllTypes.REGULATEDAUTHORIZATION)
6124        return "RegulatedAuthorization";
6125      if (code == FHIRAllTypes.RELATEDPERSON)
6126        return "RelatedPerson";
6127      if (code == FHIRAllTypes.REQUESTGROUP)
6128        return "RequestGroup";
6129      if (code == FHIRAllTypes.RESEARCHSTUDY)
6130        return "ResearchStudy";
6131      if (code == FHIRAllTypes.RESEARCHSUBJECT)
6132        return "ResearchSubject";
6133      if (code == FHIRAllTypes.RESOURCE)
6134        return "Resource";
6135      if (code == FHIRAllTypes.RISKASSESSMENT)
6136        return "RiskAssessment";
6137      if (code == FHIRAllTypes.SCHEDULE)
6138        return "Schedule";
6139      if (code == FHIRAllTypes.SEARCHPARAMETER)
6140        return "SearchParameter";
6141      if (code == FHIRAllTypes.SERVICEREQUEST)
6142        return "ServiceRequest";
6143      if (code == FHIRAllTypes.SLOT)
6144        return "Slot";
6145      if (code == FHIRAllTypes.SPECIMEN)
6146        return "Specimen";
6147      if (code == FHIRAllTypes.SPECIMENDEFINITION)
6148        return "SpecimenDefinition";
6149      if (code == FHIRAllTypes.STRUCTUREDEFINITION)
6150        return "StructureDefinition";
6151      if (code == FHIRAllTypes.STRUCTUREMAP)
6152        return "StructureMap";
6153      if (code == FHIRAllTypes.SUBSCRIPTION)
6154        return "Subscription";
6155      if (code == FHIRAllTypes.SUBSTANCE)
6156        return "Substance";
6157      if (code == FHIRAllTypes.SUBSTANCEDEFINITION)
6158        return "SubstanceDefinition";
6159      if (code == FHIRAllTypes.SUBSTANCENUCLEICACID)
6160        return "SubstanceNucleicAcid";
6161      if (code == FHIRAllTypes.SUBSTANCEPOLYMER)
6162        return "SubstancePolymer";
6163      if (code == FHIRAllTypes.SUBSTANCEPROTEIN)
6164        return "SubstanceProtein";
6165      if (code == FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION)
6166        return "SubstanceReferenceInformation";
6167      if (code == FHIRAllTypes.SUBSTANCESOURCEMATERIAL)
6168        return "SubstanceSourceMaterial";
6169      if (code == FHIRAllTypes.SUPPLYDELIVERY)
6170        return "SupplyDelivery";
6171      if (code == FHIRAllTypes.SUPPLYREQUEST)
6172        return "SupplyRequest";
6173      if (code == FHIRAllTypes.TASK)
6174        return "Task";
6175      if (code == FHIRAllTypes.TERMINOLOGYCAPABILITIES)
6176        return "TerminologyCapabilities";
6177      if (code == FHIRAllTypes.TESTREPORT)
6178        return "TestReport";
6179      if (code == FHIRAllTypes.TESTSCRIPT)
6180        return "TestScript";
6181      if (code == FHIRAllTypes.TOPIC)
6182        return "Topic";
6183      if (code == FHIRAllTypes.VALUESET)
6184        return "ValueSet";
6185      if (code == FHIRAllTypes.VERIFICATIONRESULT)
6186        return "VerificationResult";
6187      if (code == FHIRAllTypes.VISIONPRESCRIPTION)
6188        return "VisionPrescription";
6189      if (code == FHIRAllTypes.TYPE)
6190        return "Type";
6191      if (code == FHIRAllTypes.ANY)
6192        return "Any";
6193      return "?";
6194      }
6195    public String toSystem(FHIRAllTypes code) {
6196      return code.getSystem();
6197      }
6198    }
6199
6200    public enum FHIRVersion {
6201        /**
6202         * Oldest archived version of FHIR.
6203         */
6204        _0_01, 
6205        /**
6206         * 1st Draft for Comment (Sept 2012 Ballot).
6207         */
6208        _0_05, 
6209        /**
6210         * 2nd Draft for Comment (January 2013 Ballot).
6211         */
6212        _0_06, 
6213        /**
6214         * DSTU 1 Ballot version.
6215         */
6216        _0_11, 
6217        /**
6218         * DSTU 1 Official version.
6219         */
6220        _0_0_80, 
6221        /**
6222         * DSTU 1 Official version Technical Errata #1.
6223         */
6224        _0_0_81, 
6225        /**
6226         * DSTU 1 Official version Technical Errata #2.
6227         */
6228        _0_0_82, 
6229        /**
6230         * Draft For Comment (January 2015 Ballot).
6231         */
6232        _0_4_0, 
6233        /**
6234         * DSTU 2 Ballot version (May 2015 Ballot).
6235         */
6236        _0_5_0, 
6237        /**
6238         * DSTU 2 QA Preview + CQIF Ballot (Sep 2015).
6239         */
6240        _1_0_0, 
6241        /**
6242         * DSTU 2 (Official version).
6243         */
6244        _1_0_1, 
6245        /**
6246         * DSTU 2 (Official version) with 1 technical errata.
6247         */
6248        _1_0_2, 
6249        /**
6250         * GAO Ballot + draft changes to main FHIR standard.
6251         */
6252        _1_1_0, 
6253        /**
6254         * CQF on FHIR Ballot + Connectathon 12 (Montreal).
6255         */
6256        _1_4_0, 
6257        /**
6258         * FHIR STU3 Ballot + Connectathon 13 (Baltimore).
6259         */
6260        _1_6_0, 
6261        /**
6262         * FHIR STU3 Candidate + Connectathon 14 (San Antonio).
6263         */
6264        _1_8_0, 
6265        /**
6266         * FHIR Release 3 (STU).
6267         */
6268        _3_0_0, 
6269        /**
6270         * FHIR Release 3 (STU) with 1 technical errata.
6271         */
6272        _3_0_1, 
6273        /**
6274         * FHIR Release 3 (STU) with 2 technical errata.
6275         */
6276        _3_0_2, 
6277        /**
6278         * R4 Ballot #1.
6279         */
6280        _3_3_0, 
6281        /**
6282         * R4 Ballot #2.
6283         */
6284        _3_5_0, 
6285        /**
6286         * FHIR Release 4 (Normative + STU).
6287         */
6288        _4_0_0, 
6289        /**
6290         * FHIR Release 4 (Normative + STU) with 1 technical errata.
6291         */
6292        _4_0_1, 
6293        /**
6294         * R5 Preview #1.
6295         */
6296        _4_2_0, 
6297        /**
6298         * added to help the parsers
6299         */
6300        NULL;
6301        public static FHIRVersion fromCode(String codeString) throws FHIRException {
6302            if (codeString == null || "".equals(codeString))
6303                return null;
6304        if ("0.01".equals(codeString))
6305          return _0_01;
6306        if ("0.05".equals(codeString))
6307          return _0_05;
6308        if ("0.06".equals(codeString))
6309          return _0_06;
6310        if ("0.11".equals(codeString))
6311          return _0_11;
6312        if ("0.0.80".equals(codeString))
6313          return _0_0_80;
6314        if ("0.0.81".equals(codeString))
6315          return _0_0_81;
6316        if ("0.0.82".equals(codeString))
6317          return _0_0_82;
6318        if ("0.4.0".equals(codeString))
6319          return _0_4_0;
6320        if ("0.5.0".equals(codeString))
6321          return _0_5_0;
6322        if ("1.0.0".equals(codeString))
6323          return _1_0_0;
6324        if ("1.0.1".equals(codeString))
6325          return _1_0_1;
6326        if ("1.0.2".equals(codeString))
6327          return _1_0_2;
6328        if ("1.1.0".equals(codeString))
6329          return _1_1_0;
6330        if ("1.4.0".equals(codeString))
6331          return _1_4_0;
6332        if ("1.6.0".equals(codeString))
6333          return _1_6_0;
6334        if ("1.8.0".equals(codeString))
6335          return _1_8_0;
6336        if ("3.0.0".equals(codeString))
6337          return _3_0_0;
6338        if ("3.0.1".equals(codeString))
6339          return _3_0_1;
6340        if ("3.0.2".equals(codeString))
6341          return _3_0_2;
6342        if ("3.3.0".equals(codeString))
6343          return _3_3_0;
6344        if ("3.5.0".equals(codeString))
6345          return _3_5_0;
6346        if ("4.0.0".equals(codeString))
6347          return _4_0_0;
6348        if ("4.0.1".equals(codeString))
6349          return _4_0_1;
6350        if ("4.2.0".equals(codeString))
6351          return _4_2_0;
6352        throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'");
6353        }
6354        public String toCode() {
6355          switch (this) {
6356            case _0_01: return "0.01";
6357            case _0_05: return "0.05";
6358            case _0_06: return "0.06";
6359            case _0_11: return "0.11";
6360            case _0_0_80: return "0.0.80";
6361            case _0_0_81: return "0.0.81";
6362            case _0_0_82: return "0.0.82";
6363            case _0_4_0: return "0.4.0";
6364            case _0_5_0: return "0.5.0";
6365            case _1_0_0: return "1.0.0";
6366            case _1_0_1: return "1.0.1";
6367            case _1_0_2: return "1.0.2";
6368            case _1_1_0: return "1.1.0";
6369            case _1_4_0: return "1.4.0";
6370            case _1_6_0: return "1.6.0";
6371            case _1_8_0: return "1.8.0";
6372            case _3_0_0: return "3.0.0";
6373            case _3_0_1: return "3.0.1";
6374            case _3_0_2: return "3.0.2";
6375            case _3_3_0: return "3.3.0";
6376            case _3_5_0: return "3.5.0";
6377            case _4_0_0: return "4.0.0";
6378            case _4_0_1: return "4.0.1";
6379            case _4_2_0: return "4.2.0";
6380            default: return "?";
6381          }
6382        }
6383        public String getSystem() {
6384          switch (this) {
6385            case _0_01: return "http://hl7.org/fhir/FHIR-version";
6386            case _0_05: return "http://hl7.org/fhir/FHIR-version";
6387            case _0_06: return "http://hl7.org/fhir/FHIR-version";
6388            case _0_11: return "http://hl7.org/fhir/FHIR-version";
6389            case _0_0_80: return "http://hl7.org/fhir/FHIR-version";
6390            case _0_0_81: return "http://hl7.org/fhir/FHIR-version";
6391            case _0_0_82: return "http://hl7.org/fhir/FHIR-version";
6392            case _0_4_0: return "http://hl7.org/fhir/FHIR-version";
6393            case _0_5_0: return "http://hl7.org/fhir/FHIR-version";
6394            case _1_0_0: return "http://hl7.org/fhir/FHIR-version";
6395            case _1_0_1: return "http://hl7.org/fhir/FHIR-version";
6396            case _1_0_2: return "http://hl7.org/fhir/FHIR-version";
6397            case _1_1_0: return "http://hl7.org/fhir/FHIR-version";
6398            case _1_4_0: return "http://hl7.org/fhir/FHIR-version";
6399            case _1_6_0: return "http://hl7.org/fhir/FHIR-version";
6400            case _1_8_0: return "http://hl7.org/fhir/FHIR-version";
6401            case _3_0_0: return "http://hl7.org/fhir/FHIR-version";
6402            case _3_0_1: return "http://hl7.org/fhir/FHIR-version";
6403            case _3_0_2: return "http://hl7.org/fhir/FHIR-version";
6404            case _3_3_0: return "http://hl7.org/fhir/FHIR-version";
6405            case _3_5_0: return "http://hl7.org/fhir/FHIR-version";
6406            case _4_0_0: return "http://hl7.org/fhir/FHIR-version";
6407            case _4_0_1: return "http://hl7.org/fhir/FHIR-version";
6408            case _4_2_0: return "http://hl7.org/fhir/FHIR-version";
6409            default: return "?";
6410          }
6411        }
6412        public String getDefinition() {
6413          switch (this) {
6414            case _0_01: return "Oldest archived version of FHIR.";
6415            case _0_05: return "1st Draft for Comment (Sept 2012 Ballot).";
6416            case _0_06: return "2nd Draft for Comment (January 2013 Ballot).";
6417            case _0_11: return "DSTU 1 Ballot version.";
6418            case _0_0_80: return "DSTU 1 Official version.";
6419            case _0_0_81: return "DSTU 1 Official version Technical Errata #1.";
6420            case _0_0_82: return "DSTU 1 Official version Technical Errata #2.";
6421            case _0_4_0: return "Draft For Comment (January 2015 Ballot).";
6422            case _0_5_0: return "DSTU 2 Ballot version (May 2015 Ballot).";
6423            case _1_0_0: return "DSTU 2 QA Preview + CQIF Ballot (Sep 2015).";
6424            case _1_0_1: return "DSTU 2 (Official version).";
6425            case _1_0_2: return "DSTU 2 (Official version) with 1 technical errata.";
6426            case _1_1_0: return "GAO Ballot + draft changes to main FHIR standard.";
6427            case _1_4_0: return "CQF on FHIR Ballot + Connectathon 12 (Montreal).";
6428            case _1_6_0: return "FHIR STU3 Ballot + Connectathon 13 (Baltimore).";
6429            case _1_8_0: return "FHIR STU3 Candidate + Connectathon 14 (San Antonio).";
6430            case _3_0_0: return "FHIR Release 3 (STU).";
6431            case _3_0_1: return "FHIR Release 3 (STU) with 1 technical errata.";
6432            case _3_0_2: return "FHIR Release 3 (STU) with 2 technical errata.";
6433            case _3_3_0: return "R4 Ballot #1.";
6434            case _3_5_0: return "R4 Ballot #2.";
6435            case _4_0_0: return "FHIR Release 4 (Normative + STU).";
6436            case _4_0_1: return "FHIR Release 4 (Normative + STU) with 1 technical errata.";
6437            case _4_2_0: return "R5 Preview #1.";
6438            default: return "?";
6439          }
6440        }
6441        public String getDisplay() {
6442          switch (this) {
6443            case _0_01: return "0.01";
6444            case _0_05: return "0.05";
6445            case _0_06: return "0.06";
6446            case _0_11: return "0.11";
6447            case _0_0_80: return "0.0.80";
6448            case _0_0_81: return "0.0.81";
6449            case _0_0_82: return "0.0.82";
6450            case _0_4_0: return "0.4.0";
6451            case _0_5_0: return "0.5.0";
6452            case _1_0_0: return "1.0.0";
6453            case _1_0_1: return "1.0.1";
6454            case _1_0_2: return "1.0.2";
6455            case _1_1_0: return "1.1.0";
6456            case _1_4_0: return "1.4.0";
6457            case _1_6_0: return "1.6.0";
6458            case _1_8_0: return "1.8.0";
6459            case _3_0_0: return "3.0.0";
6460            case _3_0_1: return "3.0.1";
6461            case _3_0_2: return "3.0.2";
6462            case _3_3_0: return "3.3.0";
6463            case _3_5_0: return "3.5.0";
6464            case _4_0_0: return "4.0.0";
6465            case _4_0_1: return "4.0.1";
6466            case _4_2_0: return "4.2.0";
6467            default: return "?";
6468          }
6469        }
6470// manual code from configuration.txt:
6471        public String toCode(int len) {
6472          return toCode().substring(0, len);
6473        }
6474
6475        public static boolean isR4Plus(String version) {
6476           return version != null && (version.startsWith("4.") || version.startsWith("5.") || "current".equals(version));
6477        }
6478        
6479       public static boolean isValidCode(String codeString) {
6480          if (codeString == null || "".equals(codeString))
6481              return false;
6482      if ("0.01".equals(codeString))
6483        return true;
6484      if ("0.05".equals(codeString))
6485        return true;
6486      if ("0.06".equals(codeString))
6487        return true;
6488      if ("0.11".equals(codeString))
6489        return true;
6490      if ("0.0.80".equals(codeString))
6491        return true;
6492      if ("0.0.81".equals(codeString))
6493        return true;
6494      if ("0.0.82".equals(codeString))
6495        return true;
6496      if ("0.4.0".equals(codeString))
6497        return true;
6498      if ("0.5.0".equals(codeString))
6499        return true;
6500      if ("1.0.0".equals(codeString))
6501        return true;
6502      if ("1.0.1".equals(codeString))
6503        return true;
6504      if ("1.0.2".equals(codeString))
6505        return true;
6506      if ("1.1.0".equals(codeString))
6507        return true;
6508      if ("1.4.0".equals(codeString))
6509        return true;
6510      if ("1.6.0".equals(codeString))
6511        return true;
6512      if ("1.8.0".equals(codeString))
6513        return true;
6514      if ("3.0.0".equals(codeString))
6515        return true;
6516      if ("3.0.1".equals(codeString))
6517        return true;
6518      if ("3.3.0".equals(codeString))
6519        return true;
6520      if ("3.5.0".equals(codeString))
6521        return true;
6522      if ("4.0.0".equals(codeString))
6523        return true;
6524      if ("4.2.0".equals(codeString))
6525        return true;
6526      return false;
6527      }
6528
6529        @Override
6530        public String toString() {
6531          return toCode();
6532        }        
6533
6534// end addition
6535    }
6536
6537  public static class FHIRVersionEnumFactory implements EnumFactory<FHIRVersion> {
6538    public FHIRVersion fromCode(String codeString) throws IllegalArgumentException {
6539      if (codeString == null || "".equals(codeString))
6540            if (codeString == null || "".equals(codeString))
6541                return null;
6542        if ("0.01".equals(codeString))
6543          return FHIRVersion._0_01;
6544        if ("0.05".equals(codeString))
6545          return FHIRVersion._0_05;
6546        if ("0.06".equals(codeString))
6547          return FHIRVersion._0_06;
6548        if ("0.11".equals(codeString))
6549          return FHIRVersion._0_11;
6550        if ("0.0.80".equals(codeString))
6551          return FHIRVersion._0_0_80;
6552        if ("0.0.81".equals(codeString))
6553          return FHIRVersion._0_0_81;
6554        if ("0.0.82".equals(codeString))
6555          return FHIRVersion._0_0_82;
6556        if ("0.4.0".equals(codeString))
6557          return FHIRVersion._0_4_0;
6558        if ("0.5.0".equals(codeString))
6559          return FHIRVersion._0_5_0;
6560        if ("1.0.0".equals(codeString))
6561          return FHIRVersion._1_0_0;
6562        if ("1.0.1".equals(codeString))
6563          return FHIRVersion._1_0_1;
6564        if ("1.0.2".equals(codeString))
6565          return FHIRVersion._1_0_2;
6566        if ("1.1.0".equals(codeString))
6567          return FHIRVersion._1_1_0;
6568        if ("1.4.0".equals(codeString))
6569          return FHIRVersion._1_4_0;
6570        if ("1.6.0".equals(codeString))
6571          return FHIRVersion._1_6_0;
6572        if ("1.8.0".equals(codeString))
6573          return FHIRVersion._1_8_0;
6574        if ("3.0.0".equals(codeString))
6575          return FHIRVersion._3_0_0;
6576        if ("3.0.1".equals(codeString))
6577          return FHIRVersion._3_0_1;
6578        if ("3.0.2".equals(codeString))
6579          return FHIRVersion._3_0_2;
6580        if ("3.3.0".equals(codeString))
6581          return FHIRVersion._3_3_0;
6582        if ("3.5.0".equals(codeString))
6583          return FHIRVersion._3_5_0;
6584        if ("4.0.0".equals(codeString))
6585          return FHIRVersion._4_0_0;
6586        if ("4.0.1".equals(codeString))
6587          return FHIRVersion._4_0_1;
6588        if ("4.2.0".equals(codeString))
6589          return FHIRVersion._4_2_0;
6590        throw new IllegalArgumentException("Unknown FHIRVersion code '"+codeString+"'");
6591        }
6592        public Enumeration<FHIRVersion> fromType(Base code) throws FHIRException {
6593          if (code == null)
6594            return null;
6595          if (code.isEmpty())
6596            return new Enumeration<FHIRVersion>(this);
6597          String codeString = ((PrimitiveType) code).asStringValue();
6598          if (codeString == null || "".equals(codeString))
6599            return null;
6600        if ("0.01".equals(codeString))
6601          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_01);
6602        if ("0.05".equals(codeString))
6603          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_05);
6604        if ("0.06".equals(codeString))
6605          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_06);
6606        if ("0.11".equals(codeString))
6607          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_11);
6608        if ("0.0.80".equals(codeString))
6609          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_80);
6610        if ("0.0.81".equals(codeString))
6611          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_81);
6612        if ("0.0.82".equals(codeString))
6613          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_82);
6614        if ("0.4.0".equals(codeString))
6615          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4_0);
6616        if ("0.5.0".equals(codeString))
6617          return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5_0);
6618        if ("1.0.0".equals(codeString))
6619          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_0);
6620        if ("1.0.1".equals(codeString))
6621          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_1);
6622        if ("1.0.2".equals(codeString))
6623          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_2);
6624        if ("1.1.0".equals(codeString))
6625          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1_0);
6626        if ("1.4.0".equals(codeString))
6627          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4_0);
6628        if ("1.6.0".equals(codeString))
6629          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6_0);
6630        if ("1.8.0".equals(codeString))
6631          return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8_0);
6632        if ("3.0.0".equals(codeString))
6633          return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_0);
6634        if ("3.0.1".equals(codeString))
6635          return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_1);
6636        if ("3.0.2".equals(codeString))
6637          return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_2);
6638        if ("3.3.0".equals(codeString))
6639          return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3_0);
6640        if ("3.5.0".equals(codeString))
6641          return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5_0);
6642        if ("4.0.0".equals(codeString))
6643          return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_0);
6644        if ("4.0.1".equals(codeString))
6645          return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_1);
6646        if ("4.2.0".equals(codeString))
6647          return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2_0);
6648        throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'");
6649        }
6650    public String toCode(FHIRVersion code) {
6651      if (code == FHIRVersion._0_01)
6652        return "0.01";
6653      if (code == FHIRVersion._0_05)
6654        return "0.05";
6655      if (code == FHIRVersion._0_06)
6656        return "0.06";
6657      if (code == FHIRVersion._0_11)
6658        return "0.11";
6659      if (code == FHIRVersion._0_0_80)
6660        return "0.0.80";
6661      if (code == FHIRVersion._0_0_81)
6662        return "0.0.81";
6663      if (code == FHIRVersion._0_0_82)
6664        return "0.0.82";
6665      if (code == FHIRVersion._0_4_0)
6666        return "0.4.0";
6667      if (code == FHIRVersion._0_5_0)
6668        return "0.5.0";
6669      if (code == FHIRVersion._1_0_0)
6670        return "1.0.0";
6671      if (code == FHIRVersion._1_0_1)
6672        return "1.0.1";
6673      if (code == FHIRVersion._1_0_2)
6674        return "1.0.2";
6675      if (code == FHIRVersion._1_1_0)
6676        return "1.1.0";
6677      if (code == FHIRVersion._1_4_0)
6678        return "1.4.0";
6679      if (code == FHIRVersion._1_6_0)
6680        return "1.6.0";
6681      if (code == FHIRVersion._1_8_0)
6682        return "1.8.0";
6683      if (code == FHIRVersion._3_0_0)
6684        return "3.0.0";
6685      if (code == FHIRVersion._3_0_1)
6686        return "3.0.1";
6687      if (code == FHIRVersion._3_0_2)
6688        return "3.0.2";
6689      if (code == FHIRVersion._3_3_0)
6690        return "3.3.0";
6691      if (code == FHIRVersion._3_5_0)
6692        return "3.5.0";
6693      if (code == FHIRVersion._4_0_0)
6694        return "4.0.0";
6695      if (code == FHIRVersion._4_0_1)
6696        return "4.0.1";
6697      if (code == FHIRVersion._4_2_0)
6698        return "4.2.0";
6699      return "?";
6700      }
6701    public String toSystem(FHIRVersion code) {
6702      return code.getSystem();
6703      }
6704    }
6705
6706    public enum FilterOperator {
6707        /**
6708         * The specified property of the code equals the provided value.
6709         */
6710        EQUAL, 
6711        /**
6712         * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self).
6713         */
6714        ISA, 
6715        /**
6716         * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself i.e. include descendant codes only).
6717         */
6718        DESCENDENTOF, 
6719        /**
6720         * The specified property of the code does not have an is-a relationship with the provided value.
6721         */
6722        ISNOTA, 
6723        /**
6724         * The specified property of the code  matches the regex specified in the provided value.
6725         */
6726        REGEX, 
6727        /**
6728         * The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list).
6729         */
6730        IN, 
6731        /**
6732         * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list).
6733         */
6734        NOTIN, 
6735        /**
6736         * Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self).
6737         */
6738        GENERALIZES, 
6739        /**
6740         * The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values).
6741         */
6742        EXISTS, 
6743        /**
6744         * added to help the parsers
6745         */
6746        NULL;
6747        public static FilterOperator fromCode(String codeString) throws FHIRException {
6748            if (codeString == null || "".equals(codeString))
6749                return null;
6750        if ("=".equals(codeString))
6751          return EQUAL;
6752        if ("is-a".equals(codeString))
6753          return ISA;
6754        if ("descendent-of".equals(codeString))
6755          return DESCENDENTOF;
6756        if ("is-not-a".equals(codeString))
6757          return ISNOTA;
6758        if ("regex".equals(codeString))
6759          return REGEX;
6760        if ("in".equals(codeString))
6761          return IN;
6762        if ("not-in".equals(codeString))
6763          return NOTIN;
6764        if ("generalizes".equals(codeString))
6765          return GENERALIZES;
6766        if ("exists".equals(codeString))
6767          return EXISTS;
6768        throw new FHIRException("Unknown FilterOperator code '"+codeString+"'");
6769        }
6770        public String toCode() {
6771          switch (this) {
6772            case EQUAL: return "=";
6773            case ISA: return "is-a";
6774            case DESCENDENTOF: return "descendent-of";
6775            case ISNOTA: return "is-not-a";
6776            case REGEX: return "regex";
6777            case IN: return "in";
6778            case NOTIN: return "not-in";
6779            case GENERALIZES: return "generalizes";
6780            case EXISTS: return "exists";
6781            default: return "?";
6782          }
6783        }
6784        public String getSystem() {
6785          switch (this) {
6786            case EQUAL: return "http://hl7.org/fhir/filter-operator";
6787            case ISA: return "http://hl7.org/fhir/filter-operator";
6788            case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator";
6789            case ISNOTA: return "http://hl7.org/fhir/filter-operator";
6790            case REGEX: return "http://hl7.org/fhir/filter-operator";
6791            case IN: return "http://hl7.org/fhir/filter-operator";
6792            case NOTIN: return "http://hl7.org/fhir/filter-operator";
6793            case GENERALIZES: return "http://hl7.org/fhir/filter-operator";
6794            case EXISTS: return "http://hl7.org/fhir/filter-operator";
6795            default: return "?";
6796          }
6797        }
6798        public String getDefinition() {
6799          switch (this) {
6800            case EQUAL: return "The specified property of the code equals the provided value.";
6801            case ISA: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self).";
6802            case DESCENDENTOF: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself i.e. include descendant codes only).";
6803            case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value.";
6804            case REGEX: return "The specified property of the code  matches the regex specified in the provided value.";
6805            case IN: return "The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list).";
6806            case NOTIN: return "The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list).";
6807            case GENERALIZES: return "Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self).";
6808            case EXISTS: return "The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values).";
6809            default: return "?";
6810          }
6811        }
6812        public String getDisplay() {
6813          switch (this) {
6814            case EQUAL: return "Equals";
6815            case ISA: return "Is A (by subsumption)";
6816            case DESCENDENTOF: return "Descendent Of (by subsumption)";
6817            case ISNOTA: return "Not (Is A) (by subsumption)";
6818            case REGEX: return "Regular Expression";
6819            case IN: return "In Set";
6820            case NOTIN: return "Not in Set";
6821            case GENERALIZES: return "Generalizes (by Subsumption)";
6822            case EXISTS: return "Exists";
6823            default: return "?";
6824          }
6825        }
6826    }
6827
6828  public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> {
6829    public FilterOperator fromCode(String codeString) throws IllegalArgumentException {
6830      if (codeString == null || "".equals(codeString))
6831            if (codeString == null || "".equals(codeString))
6832                return null;
6833        if ("=".equals(codeString))
6834          return FilterOperator.EQUAL;
6835        if ("is-a".equals(codeString))
6836          return FilterOperator.ISA;
6837        if ("descendent-of".equals(codeString))
6838          return FilterOperator.DESCENDENTOF;
6839        if ("is-not-a".equals(codeString))
6840          return FilterOperator.ISNOTA;
6841        if ("regex".equals(codeString))
6842          return FilterOperator.REGEX;
6843        if ("in".equals(codeString))
6844          return FilterOperator.IN;
6845        if ("not-in".equals(codeString))
6846          return FilterOperator.NOTIN;
6847        if ("generalizes".equals(codeString))
6848          return FilterOperator.GENERALIZES;
6849        if ("exists".equals(codeString))
6850          return FilterOperator.EXISTS;
6851        throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'");
6852        }
6853        public Enumeration<FilterOperator> fromType(Base code) throws FHIRException {
6854          if (code == null)
6855            return null;
6856          if (code.isEmpty())
6857            return new Enumeration<FilterOperator>(this);
6858          String codeString = ((PrimitiveType) code).asStringValue();
6859          if (codeString == null || "".equals(codeString))
6860            return null;
6861        if ("=".equals(codeString))
6862          return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL);
6863        if ("is-a".equals(codeString))
6864          return new Enumeration<FilterOperator>(this, FilterOperator.ISA);
6865        if ("descendent-of".equals(codeString))
6866          return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF);
6867        if ("is-not-a".equals(codeString))
6868          return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA);
6869        if ("regex".equals(codeString))
6870          return new Enumeration<FilterOperator>(this, FilterOperator.REGEX);
6871        if ("in".equals(codeString))
6872          return new Enumeration<FilterOperator>(this, FilterOperator.IN);
6873        if ("not-in".equals(codeString))
6874          return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN);
6875        if ("generalizes".equals(codeString))
6876          return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES);
6877        if ("exists".equals(codeString))
6878          return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS);
6879        throw new FHIRException("Unknown FilterOperator code '"+codeString+"'");
6880        }
6881    public String toCode(FilterOperator code) {
6882      if (code == FilterOperator.EQUAL)
6883        return "=";
6884      if (code == FilterOperator.ISA)
6885        return "is-a";
6886      if (code == FilterOperator.DESCENDENTOF)
6887        return "descendent-of";
6888      if (code == FilterOperator.ISNOTA)
6889        return "is-not-a";
6890      if (code == FilterOperator.REGEX)
6891        return "regex";
6892      if (code == FilterOperator.IN)
6893        return "in";
6894      if (code == FilterOperator.NOTIN)
6895        return "not-in";
6896      if (code == FilterOperator.GENERALIZES)
6897        return "generalizes";
6898      if (code == FilterOperator.EXISTS)
6899        return "exists";
6900      return "?";
6901      }
6902    public String toSystem(FilterOperator code) {
6903      return code.getSystem();
6904      }
6905    }
6906
6907    public enum FinancialResourceStatusCodes {
6908        /**
6909         * The instance is currently in-force.
6910         */
6911        ACTIVE, 
6912        /**
6913         * The instance is withdrawn, rescinded or reversed.
6914         */
6915        CANCELLED, 
6916        /**
6917         * A new instance the contents of which is not complete.
6918         */
6919        DRAFT, 
6920        /**
6921         * The instance was entered in error.
6922         */
6923        ENTEREDINERROR, 
6924        /**
6925         * added to help the parsers
6926         */
6927        NULL;
6928        public static FinancialResourceStatusCodes fromCode(String codeString) throws FHIRException {
6929            if (codeString == null || "".equals(codeString))
6930                return null;
6931        if ("active".equals(codeString))
6932          return ACTIVE;
6933        if ("cancelled".equals(codeString))
6934          return CANCELLED;
6935        if ("draft".equals(codeString))
6936          return DRAFT;
6937        if ("entered-in-error".equals(codeString))
6938          return ENTEREDINERROR;
6939        throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'");
6940        }
6941        public String toCode() {
6942          switch (this) {
6943            case ACTIVE: return "active";
6944            case CANCELLED: return "cancelled";
6945            case DRAFT: return "draft";
6946            case ENTEREDINERROR: return "entered-in-error";
6947            default: return "?";
6948          }
6949        }
6950        public String getSystem() {
6951          switch (this) {
6952            case ACTIVE: return "http://hl7.org/fhir/fm-status";
6953            case CANCELLED: return "http://hl7.org/fhir/fm-status";
6954            case DRAFT: return "http://hl7.org/fhir/fm-status";
6955            case ENTEREDINERROR: return "http://hl7.org/fhir/fm-status";
6956            default: return "?";
6957          }
6958        }
6959        public String getDefinition() {
6960          switch (this) {
6961            case ACTIVE: return "The instance is currently in-force.";
6962            case CANCELLED: return "The instance is withdrawn, rescinded or reversed.";
6963            case DRAFT: return "A new instance the contents of which is not complete.";
6964            case ENTEREDINERROR: return "The instance was entered in error.";
6965            default: return "?";
6966          }
6967        }
6968        public String getDisplay() {
6969          switch (this) {
6970            case ACTIVE: return "Active";
6971            case CANCELLED: return "Cancelled";
6972            case DRAFT: return "Draft";
6973            case ENTEREDINERROR: return "Entered in Error";
6974            default: return "?";
6975          }
6976        }
6977    }
6978
6979  public static class FinancialResourceStatusCodesEnumFactory implements EnumFactory<FinancialResourceStatusCodes> {
6980    public FinancialResourceStatusCodes fromCode(String codeString) throws IllegalArgumentException {
6981      if (codeString == null || "".equals(codeString))
6982            if (codeString == null || "".equals(codeString))
6983                return null;
6984        if ("active".equals(codeString))
6985          return FinancialResourceStatusCodes.ACTIVE;
6986        if ("cancelled".equals(codeString))
6987          return FinancialResourceStatusCodes.CANCELLED;
6988        if ("draft".equals(codeString))
6989          return FinancialResourceStatusCodes.DRAFT;
6990        if ("entered-in-error".equals(codeString))
6991          return FinancialResourceStatusCodes.ENTEREDINERROR;
6992        throw new IllegalArgumentException("Unknown FinancialResourceStatusCodes code '"+codeString+"'");
6993        }
6994        public Enumeration<FinancialResourceStatusCodes> fromType(Base code) throws FHIRException {
6995          if (code == null)
6996            return null;
6997          if (code.isEmpty())
6998            return new Enumeration<FinancialResourceStatusCodes>(this);
6999          String codeString = ((PrimitiveType) code).asStringValue();
7000          if (codeString == null || "".equals(codeString))
7001            return null;
7002        if ("active".equals(codeString))
7003          return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ACTIVE);
7004        if ("cancelled".equals(codeString))
7005          return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.CANCELLED);
7006        if ("draft".equals(codeString))
7007          return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.DRAFT);
7008        if ("entered-in-error".equals(codeString))
7009          return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ENTEREDINERROR);
7010        throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'");
7011        }
7012    public String toCode(FinancialResourceStatusCodes code) {
7013      if (code == FinancialResourceStatusCodes.ACTIVE)
7014        return "active";
7015      if (code == FinancialResourceStatusCodes.CANCELLED)
7016        return "cancelled";
7017      if (code == FinancialResourceStatusCodes.DRAFT)
7018        return "draft";
7019      if (code == FinancialResourceStatusCodes.ENTEREDINERROR)
7020        return "entered-in-error";
7021      return "?";
7022      }
7023    public String toSystem(FinancialResourceStatusCodes code) {
7024      return code.getSystem();
7025      }
7026    }
7027
7028    public enum InvoicePriceComponentType {
7029        /**
7030         * the amount is the base price used for calculating the total price before applying surcharges, discount or taxes.
7031         */
7032        BASE, 
7033        /**
7034         * the amount is a surcharge applied on the base price.
7035         */
7036        SURCHARGE, 
7037        /**
7038         * the amount is a deduction applied on the base price.
7039         */
7040        DEDUCTION, 
7041        /**
7042         * the amount is a discount applied on the base price.
7043         */
7044        DISCOUNT, 
7045        /**
7046         * the amount is the tax component of the total price.
7047         */
7048        TAX, 
7049        /**
7050         * the amount is of informational character, it has not been applied in the calculation of the total price.
7051         */
7052        INFORMATIONAL, 
7053        /**
7054         * added to help the parsers
7055         */
7056        NULL;
7057        public static InvoicePriceComponentType fromCode(String codeString) throws FHIRException {
7058            if (codeString == null || "".equals(codeString))
7059                return null;
7060        if ("base".equals(codeString))
7061          return BASE;
7062        if ("surcharge".equals(codeString))
7063          return SURCHARGE;
7064        if ("deduction".equals(codeString))
7065          return DEDUCTION;
7066        if ("discount".equals(codeString))
7067          return DISCOUNT;
7068        if ("tax".equals(codeString))
7069          return TAX;
7070        if ("informational".equals(codeString))
7071          return INFORMATIONAL;
7072        throw new FHIRException("Unknown InvoicePriceComponentType code '"+codeString+"'");
7073        }
7074        public String toCode() {
7075          switch (this) {
7076            case BASE: return "base";
7077            case SURCHARGE: return "surcharge";
7078            case DEDUCTION: return "deduction";
7079            case DISCOUNT: return "discount";
7080            case TAX: return "tax";
7081            case INFORMATIONAL: return "informational";
7082            default: return "?";
7083          }
7084        }
7085        public String getSystem() {
7086          switch (this) {
7087            case BASE: return "http://hl7.org/fhir/invoice-priceComponentType";
7088            case SURCHARGE: return "http://hl7.org/fhir/invoice-priceComponentType";
7089            case DEDUCTION: return "http://hl7.org/fhir/invoice-priceComponentType";
7090            case DISCOUNT: return "http://hl7.org/fhir/invoice-priceComponentType";
7091            case TAX: return "http://hl7.org/fhir/invoice-priceComponentType";
7092            case INFORMATIONAL: return "http://hl7.org/fhir/invoice-priceComponentType";
7093            default: return "?";
7094          }
7095        }
7096        public String getDefinition() {
7097          switch (this) {
7098            case BASE: return "the amount is the base price used for calculating the total price before applying surcharges, discount or taxes.";
7099            case SURCHARGE: return "the amount is a surcharge applied on the base price.";
7100            case DEDUCTION: return "the amount is a deduction applied on the base price.";
7101            case DISCOUNT: return "the amount is a discount applied on the base price.";
7102            case TAX: return "the amount is the tax component of the total price.";
7103            case INFORMATIONAL: return "the amount is of informational character, it has not been applied in the calculation of the total price.";
7104            default: return "?";
7105          }
7106        }
7107        public String getDisplay() {
7108          switch (this) {
7109            case BASE: return "base price";
7110            case SURCHARGE: return "surcharge";
7111            case DEDUCTION: return "deduction";
7112            case DISCOUNT: return "discount";
7113            case TAX: return "tax";
7114            case INFORMATIONAL: return "informational";
7115            default: return "?";
7116          }
7117        }
7118    }
7119
7120  public static class InvoicePriceComponentTypeEnumFactory implements EnumFactory<InvoicePriceComponentType> {
7121    public InvoicePriceComponentType fromCode(String codeString) throws IllegalArgumentException {
7122      if (codeString == null || "".equals(codeString))
7123            if (codeString == null || "".equals(codeString))
7124                return null;
7125        if ("base".equals(codeString))
7126          return InvoicePriceComponentType.BASE;
7127        if ("surcharge".equals(codeString))
7128          return InvoicePriceComponentType.SURCHARGE;
7129        if ("deduction".equals(codeString))
7130          return InvoicePriceComponentType.DEDUCTION;
7131        if ("discount".equals(codeString))
7132          return InvoicePriceComponentType.DISCOUNT;
7133        if ("tax".equals(codeString))
7134          return InvoicePriceComponentType.TAX;
7135        if ("informational".equals(codeString))
7136          return InvoicePriceComponentType.INFORMATIONAL;
7137        throw new IllegalArgumentException("Unknown InvoicePriceComponentType code '"+codeString+"'");
7138        }
7139        public Enumeration<InvoicePriceComponentType> fromType(Base code) throws FHIRException {
7140          if (code == null)
7141            return null;
7142          if (code.isEmpty())
7143            return new Enumeration<InvoicePriceComponentType>(this);
7144          String codeString = ((PrimitiveType) code).asStringValue();
7145          if (codeString == null || "".equals(codeString))
7146            return null;
7147        if ("base".equals(codeString))
7148          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.BASE);
7149        if ("surcharge".equals(codeString))
7150          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.SURCHARGE);
7151        if ("deduction".equals(codeString))
7152          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.DEDUCTION);
7153        if ("discount".equals(codeString))
7154          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.DISCOUNT);
7155        if ("tax".equals(codeString))
7156          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.TAX);
7157        if ("informational".equals(codeString))
7158          return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.INFORMATIONAL);
7159        throw new FHIRException("Unknown InvoicePriceComponentType code '"+codeString+"'");
7160        }
7161    public String toCode(InvoicePriceComponentType code) {
7162      if (code == InvoicePriceComponentType.BASE)
7163        return "base";
7164      if (code == InvoicePriceComponentType.SURCHARGE)
7165        return "surcharge";
7166      if (code == InvoicePriceComponentType.DEDUCTION)
7167        return "deduction";
7168      if (code == InvoicePriceComponentType.DISCOUNT)
7169        return "discount";
7170      if (code == InvoicePriceComponentType.TAX)
7171        return "tax";
7172      if (code == InvoicePriceComponentType.INFORMATIONAL)
7173        return "informational";
7174      return "?";
7175      }
7176    public String toSystem(InvoicePriceComponentType code) {
7177      return code.getSystem();
7178      }
7179    }
7180
7181    public enum ListMode {
7182        /**
7183         * This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes.
7184         */
7185        WORKING, 
7186        /**
7187         * This list was prepared as a snapshot. It should not be assumed to be current.
7188         */
7189        SNAPSHOT, 
7190        /**
7191         * A point-in-time list that shows what changes have been made or recommended.  E.g. a discharge medication list showing what was added and removed during an encounter.
7192         */
7193        CHANGES, 
7194        /**
7195         * added to help the parsers
7196         */
7197        NULL;
7198        public static ListMode fromCode(String codeString) throws FHIRException {
7199            if (codeString == null || "".equals(codeString))
7200                return null;
7201        if ("working".equals(codeString))
7202          return WORKING;
7203        if ("snapshot".equals(codeString))
7204          return SNAPSHOT;
7205        if ("changes".equals(codeString))
7206          return CHANGES;
7207        throw new FHIRException("Unknown ListMode code '"+codeString+"'");
7208        }
7209        public String toCode() {
7210          switch (this) {
7211            case WORKING: return "working";
7212            case SNAPSHOT: return "snapshot";
7213            case CHANGES: return "changes";
7214            default: return "?";
7215          }
7216        }
7217        public String getSystem() {
7218          switch (this) {
7219            case WORKING: return "http://hl7.org/fhir/list-mode";
7220            case SNAPSHOT: return "http://hl7.org/fhir/list-mode";
7221            case CHANGES: return "http://hl7.org/fhir/list-mode";
7222            default: return "?";
7223          }
7224        }
7225        public String getDefinition() {
7226          switch (this) {
7227            case WORKING: return "This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes.";
7228            case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current.";
7229            case CHANGES: return "A point-in-time list that shows what changes have been made or recommended.  E.g. a discharge medication list showing what was added and removed during an encounter.";
7230            default: return "?";
7231          }
7232        }
7233        public String getDisplay() {
7234          switch (this) {
7235            case WORKING: return "Working List";
7236            case SNAPSHOT: return "Snapshot List";
7237            case CHANGES: return "Change List";
7238            default: return "?";
7239          }
7240        }
7241    }
7242
7243  public static class ListModeEnumFactory implements EnumFactory<ListMode> {
7244    public ListMode fromCode(String codeString) throws IllegalArgumentException {
7245      if (codeString == null || "".equals(codeString))
7246            if (codeString == null || "".equals(codeString))
7247                return null;
7248        if ("working".equals(codeString))
7249          return ListMode.WORKING;
7250        if ("snapshot".equals(codeString))
7251          return ListMode.SNAPSHOT;
7252        if ("changes".equals(codeString))
7253          return ListMode.CHANGES;
7254        throw new IllegalArgumentException("Unknown ListMode code '"+codeString+"'");
7255        }
7256        public Enumeration<ListMode> fromType(Base code) throws FHIRException {
7257          if (code == null)
7258            return null;
7259          if (code.isEmpty())
7260            return new Enumeration<ListMode>(this);
7261          String codeString = ((PrimitiveType) code).asStringValue();
7262          if (codeString == null || "".equals(codeString))
7263            return null;
7264        if ("working".equals(codeString))
7265          return new Enumeration<ListMode>(this, ListMode.WORKING);
7266        if ("snapshot".equals(codeString))
7267          return new Enumeration<ListMode>(this, ListMode.SNAPSHOT);
7268        if ("changes".equals(codeString))
7269          return new Enumeration<ListMode>(this, ListMode.CHANGES);
7270        throw new FHIRException("Unknown ListMode code '"+codeString+"'");
7271        }
7272    public String toCode(ListMode code) {
7273      if (code == ListMode.WORKING)
7274        return "working";
7275      if (code == ListMode.SNAPSHOT)
7276        return "snapshot";
7277      if (code == ListMode.CHANGES)
7278        return "changes";
7279      return "?";
7280      }
7281    public String toSystem(ListMode code) {
7282      return code.getSystem();
7283      }
7284    }
7285
7286    public enum MeasureImprovementNotation {
7287        /**
7288         * Improvement is indicated as an increase in the score or measurement (e.g. Higher score indicates better quality).
7289         */
7290        INCREASE, 
7291        /**
7292         * Improvement is indicated as a decrease in the score or measurement (e.g. Lower score indicates better quality).
7293         */
7294        DECREASE, 
7295        /**
7296         * added to help the parsers
7297         */
7298        NULL;
7299        public static MeasureImprovementNotation fromCode(String codeString) throws FHIRException {
7300            if (codeString == null || "".equals(codeString))
7301                return null;
7302        if ("increase".equals(codeString))
7303          return INCREASE;
7304        if ("decrease".equals(codeString))
7305          return DECREASE;
7306        throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'");
7307        }
7308        public String toCode() {
7309          switch (this) {
7310            case INCREASE: return "increase";
7311            case DECREASE: return "decrease";
7312            default: return "?";
7313          }
7314        }
7315        public String getSystem() {
7316          switch (this) {
7317            case INCREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation";
7318            case DECREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation";
7319            default: return "?";
7320          }
7321        }
7322        public String getDefinition() {
7323          switch (this) {
7324            case INCREASE: return "Improvement is indicated as an increase in the score or measurement (e.g. Higher score indicates better quality).";
7325            case DECREASE: return "Improvement is indicated as a decrease in the score or measurement (e.g. Lower score indicates better quality).";
7326            default: return "?";
7327          }
7328        }
7329        public String getDisplay() {
7330          switch (this) {
7331            case INCREASE: return "Increased score indicates improvement";
7332            case DECREASE: return "Decreased score indicates improvement";
7333            default: return "?";
7334          }
7335        }
7336    }
7337
7338  public static class MeasureImprovementNotationEnumFactory implements EnumFactory<MeasureImprovementNotation> {
7339    public MeasureImprovementNotation fromCode(String codeString) throws IllegalArgumentException {
7340      if (codeString == null || "".equals(codeString))
7341            if (codeString == null || "".equals(codeString))
7342                return null;
7343        if ("increase".equals(codeString))
7344          return MeasureImprovementNotation.INCREASE;
7345        if ("decrease".equals(codeString))
7346          return MeasureImprovementNotation.DECREASE;
7347        throw new IllegalArgumentException("Unknown MeasureImprovementNotation code '"+codeString+"'");
7348        }
7349        public Enumeration<MeasureImprovementNotation> fromType(Base code) throws FHIRException {
7350          if (code == null)
7351            return null;
7352          if (code.isEmpty())
7353            return new Enumeration<MeasureImprovementNotation>(this);
7354          String codeString = ((PrimitiveType) code).asStringValue();
7355          if (codeString == null || "".equals(codeString))
7356            return null;
7357        if ("increase".equals(codeString))
7358          return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.INCREASE);
7359        if ("decrease".equals(codeString))
7360          return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.DECREASE);
7361        throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'");
7362        }
7363    public String toCode(MeasureImprovementNotation code) {
7364      if (code == MeasureImprovementNotation.INCREASE)
7365        return "increase";
7366      if (code == MeasureImprovementNotation.DECREASE)
7367        return "decrease";
7368      return "?";
7369      }
7370    public String toSystem(MeasureImprovementNotation code) {
7371      return code.getSystem();
7372      }
7373    }
7374
7375    public enum MimeTypes {
7376        /**
7377         * added to help the parsers
7378         */
7379        NULL;
7380        public static MimeTypes fromCode(String codeString) throws FHIRException {
7381            if (codeString == null || "".equals(codeString))
7382                return null;
7383        throw new FHIRException("Unknown MimeTypes code '"+codeString+"'");
7384        }
7385        public String toCode() {
7386          switch (this) {
7387            default: return "?";
7388          }
7389        }
7390        public String getSystem() {
7391          switch (this) {
7392            default: return "?";
7393          }
7394        }
7395        public String getDefinition() {
7396          switch (this) {
7397            default: return "?";
7398          }
7399        }
7400        public String getDisplay() {
7401          switch (this) {
7402            default: return "?";
7403          }
7404        }
7405    }
7406
7407  public static class MimeTypesEnumFactory implements EnumFactory<MimeTypes> {
7408    public MimeTypes fromCode(String codeString) throws IllegalArgumentException {
7409      if (codeString == null || "".equals(codeString))
7410            if (codeString == null || "".equals(codeString))
7411                return null;
7412        throw new IllegalArgumentException("Unknown MimeTypes code '"+codeString+"'");
7413        }
7414        public Enumeration<MimeTypes> fromType(Base code) throws FHIRException {
7415          if (code == null)
7416            return null;
7417          if (code.isEmpty())
7418            return new Enumeration<MimeTypes>(this);
7419          String codeString = ((PrimitiveType) code).asStringValue();
7420          if (codeString == null || "".equals(codeString))
7421            return null;
7422        throw new FHIRException("Unknown MimeTypes code '"+codeString+"'");
7423        }
7424    public String toCode(MimeTypes code) {
7425      return "?";
7426      }
7427    public String toSystem(MimeTypes code) {
7428      return code.getSystem();
7429      }
7430    }
7431
7432    public enum NoteType {
7433        /**
7434         * Display the note.
7435         */
7436        DISPLAY, 
7437        /**
7438         * Print the note on the form.
7439         */
7440        PRINT, 
7441        /**
7442         * Print the note for the operator.
7443         */
7444        PRINTOPER, 
7445        /**
7446         * added to help the parsers
7447         */
7448        NULL;
7449        public static NoteType fromCode(String codeString) throws FHIRException {
7450            if (codeString == null || "".equals(codeString))
7451                return null;
7452        if ("display".equals(codeString))
7453          return DISPLAY;
7454        if ("print".equals(codeString))
7455          return PRINT;
7456        if ("printoper".equals(codeString))
7457          return PRINTOPER;
7458        throw new FHIRException("Unknown NoteType code '"+codeString+"'");
7459        }
7460        public String toCode() {
7461          switch (this) {
7462            case DISPLAY: return "display";
7463            case PRINT: return "print";
7464            case PRINTOPER: return "printoper";
7465            default: return "?";
7466          }
7467        }
7468        public String getSystem() {
7469          switch (this) {
7470            case DISPLAY: return "http://hl7.org/fhir/note-type";
7471            case PRINT: return "http://hl7.org/fhir/note-type";
7472            case PRINTOPER: return "http://hl7.org/fhir/note-type";
7473            default: return "?";
7474          }
7475        }
7476        public String getDefinition() {
7477          switch (this) {
7478            case DISPLAY: return "Display the note.";
7479            case PRINT: return "Print the note on the form.";
7480            case PRINTOPER: return "Print the note for the operator.";
7481            default: return "?";
7482          }
7483        }
7484        public String getDisplay() {
7485          switch (this) {
7486            case DISPLAY: return "Display";
7487            case PRINT: return "Print (Form)";
7488            case PRINTOPER: return "Print (Operator)";
7489            default: return "?";
7490          }
7491        }
7492    }
7493
7494  public static class NoteTypeEnumFactory implements EnumFactory<NoteType> {
7495    public NoteType fromCode(String codeString) throws IllegalArgumentException {
7496      if (codeString == null || "".equals(codeString))
7497            if (codeString == null || "".equals(codeString))
7498                return null;
7499        if ("display".equals(codeString))
7500          return NoteType.DISPLAY;
7501        if ("print".equals(codeString))
7502          return NoteType.PRINT;
7503        if ("printoper".equals(codeString))
7504          return NoteType.PRINTOPER;
7505        throw new IllegalArgumentException("Unknown NoteType code '"+codeString+"'");
7506        }
7507        public Enumeration<NoteType> fromType(Base code) throws FHIRException {
7508          if (code == null)
7509            return null;
7510          if (code.isEmpty())
7511            return new Enumeration<NoteType>(this);
7512          String codeString = ((PrimitiveType) code).asStringValue();
7513          if (codeString == null || "".equals(codeString))
7514            return null;
7515        if ("display".equals(codeString))
7516          return new Enumeration<NoteType>(this, NoteType.DISPLAY);
7517        if ("print".equals(codeString))
7518          return new Enumeration<NoteType>(this, NoteType.PRINT);
7519        if ("printoper".equals(codeString))
7520          return new Enumeration<NoteType>(this, NoteType.PRINTOPER);
7521        throw new FHIRException("Unknown NoteType code '"+codeString+"'");
7522        }
7523    public String toCode(NoteType code) {
7524      if (code == NoteType.DISPLAY)
7525        return "display";
7526      if (code == NoteType.PRINT)
7527        return "print";
7528      if (code == NoteType.PRINTOPER)
7529        return "printoper";
7530      return "?";
7531      }
7532    public String toSystem(NoteType code) {
7533      return code.getSystem();
7534      }
7535    }
7536
7537    public enum ObservationStatus {
7538        /**
7539         * The existence of the observation is registered, but there is no result yet available.
7540         */
7541        REGISTERED, 
7542        /**
7543         * This is an initial or interim observation: data may be incomplete or unverified.
7544         */
7545        PRELIMINARY, 
7546        /**
7547         * The observation is complete and there are no further actions needed. Additional information such "released", "signed", etc would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied.
7548         */
7549        FINAL, 
7550        /**
7551         * Subsequent to being Final, the observation has been modified subsequent.  This includes updates/new information and corrections.
7552         */
7553        AMENDED, 
7554        /**
7555         * Subsequent to being Final, the observation has been modified to correct an error in the test result.
7556         */
7557        CORRECTED, 
7558        /**
7559         * The observation is unavailable because the measurement was not started or not completed (also sometimes called "aborted").
7560         */
7561        CANCELLED, 
7562        /**
7563         * The observation has been withdrawn following previous final release.  This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be "cancelled" rather than "entered-in-error".).
7564         */
7565        ENTEREDINERROR, 
7566        /**
7567         * The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which.
7568         */
7569        UNKNOWN, 
7570        /**
7571         * added to help the parsers
7572         */
7573        NULL;
7574        public static ObservationStatus fromCode(String codeString) throws FHIRException {
7575            if (codeString == null || "".equals(codeString))
7576                return null;
7577        if ("registered".equals(codeString))
7578          return REGISTERED;
7579        if ("preliminary".equals(codeString))
7580          return PRELIMINARY;
7581        if ("final".equals(codeString))
7582          return FINAL;
7583        if ("amended".equals(codeString))
7584          return AMENDED;
7585        if ("corrected".equals(codeString))
7586          return CORRECTED;
7587        if ("cancelled".equals(codeString))
7588          return CANCELLED;
7589        if ("entered-in-error".equals(codeString))
7590          return ENTEREDINERROR;
7591        if ("unknown".equals(codeString))
7592          return UNKNOWN;
7593        throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'");
7594        }
7595        public String toCode() {
7596          switch (this) {
7597            case REGISTERED: return "registered";
7598            case PRELIMINARY: return "preliminary";
7599            case FINAL: return "final";
7600            case AMENDED: return "amended";
7601            case CORRECTED: return "corrected";
7602            case CANCELLED: return "cancelled";
7603            case ENTEREDINERROR: return "entered-in-error";
7604            case UNKNOWN: return "unknown";
7605            default: return "?";
7606          }
7607        }
7608        public String getSystem() {
7609          switch (this) {
7610            case REGISTERED: return "http://hl7.org/fhir/observation-status";
7611            case PRELIMINARY: return "http://hl7.org/fhir/observation-status";
7612            case FINAL: return "http://hl7.org/fhir/observation-status";
7613            case AMENDED: return "http://hl7.org/fhir/observation-status";
7614            case CORRECTED: return "http://hl7.org/fhir/observation-status";
7615            case CANCELLED: return "http://hl7.org/fhir/observation-status";
7616            case ENTEREDINERROR: return "http://hl7.org/fhir/observation-status";
7617            case UNKNOWN: return "http://hl7.org/fhir/observation-status";
7618            default: return "?";
7619          }
7620        }
7621        public String getDefinition() {
7622          switch (this) {
7623            case REGISTERED: return "The existence of the observation is registered, but there is no result yet available.";
7624            case PRELIMINARY: return "This is an initial or interim observation: data may be incomplete or unverified.";
7625            case FINAL: return "The observation is complete and there are no further actions needed. Additional information such \"released\", \"signed\", etc would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied.";
7626            case AMENDED: return "Subsequent to being Final, the observation has been modified subsequent.  This includes updates/new information and corrections.";
7627            case CORRECTED: return "Subsequent to being Final, the observation has been modified to correct an error in the test result.";
7628            case CANCELLED: return "The observation is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\").";
7629            case ENTEREDINERROR: return "The observation has been withdrawn following previous final release.  This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be \"cancelled\" rather than \"entered-in-error\".).";
7630            case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which.";
7631            default: return "?";
7632          }
7633        }
7634        public String getDisplay() {
7635          switch (this) {
7636            case REGISTERED: return "Registered";
7637            case PRELIMINARY: return "Preliminary";
7638            case FINAL: return "Final";
7639            case AMENDED: return "Amended";
7640            case CORRECTED: return "Corrected";
7641            case CANCELLED: return "Cancelled";
7642            case ENTEREDINERROR: return "Entered in Error";
7643            case UNKNOWN: return "Unknown";
7644            default: return "?";
7645          }
7646        }
7647    }
7648
7649  public static class ObservationStatusEnumFactory implements EnumFactory<ObservationStatus> {
7650    public ObservationStatus fromCode(String codeString) throws IllegalArgumentException {
7651      if (codeString == null || "".equals(codeString))
7652            if (codeString == null || "".equals(codeString))
7653                return null;
7654        if ("registered".equals(codeString))
7655          return ObservationStatus.REGISTERED;
7656        if ("preliminary".equals(codeString))
7657          return ObservationStatus.PRELIMINARY;
7658        if ("final".equals(codeString))
7659          return ObservationStatus.FINAL;
7660        if ("amended".equals(codeString))
7661          return ObservationStatus.AMENDED;
7662        if ("corrected".equals(codeString))
7663          return ObservationStatus.CORRECTED;
7664        if ("cancelled".equals(codeString))
7665          return ObservationStatus.CANCELLED;
7666        if ("entered-in-error".equals(codeString))
7667          return ObservationStatus.ENTEREDINERROR;
7668        if ("unknown".equals(codeString))
7669          return ObservationStatus.UNKNOWN;
7670        throw new IllegalArgumentException("Unknown ObservationStatus code '"+codeString+"'");
7671        }
7672        public Enumeration<ObservationStatus> fromType(Base code) throws FHIRException {
7673          if (code == null)
7674            return null;
7675          if (code.isEmpty())
7676            return new Enumeration<ObservationStatus>(this);
7677          String codeString = ((PrimitiveType) code).asStringValue();
7678          if (codeString == null || "".equals(codeString))
7679            return null;
7680        if ("registered".equals(codeString))
7681          return new Enumeration<ObservationStatus>(this, ObservationStatus.REGISTERED);
7682        if ("preliminary".equals(codeString))
7683          return new Enumeration<ObservationStatus>(this, ObservationStatus.PRELIMINARY);
7684        if ("final".equals(codeString))
7685          return new Enumeration<ObservationStatus>(this, ObservationStatus.FINAL);
7686        if ("amended".equals(codeString))
7687          return new Enumeration<ObservationStatus>(this, ObservationStatus.AMENDED);
7688        if ("corrected".equals(codeString))
7689          return new Enumeration<ObservationStatus>(this, ObservationStatus.CORRECTED);
7690        if ("cancelled".equals(codeString))
7691          return new Enumeration<ObservationStatus>(this, ObservationStatus.CANCELLED);
7692        if ("entered-in-error".equals(codeString))
7693          return new Enumeration<ObservationStatus>(this, ObservationStatus.ENTEREDINERROR);
7694        if ("unknown".equals(codeString))
7695          return new Enumeration<ObservationStatus>(this, ObservationStatus.UNKNOWN);
7696        throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'");
7697        }
7698    public String toCode(ObservationStatus code) {
7699      if (code == ObservationStatus.REGISTERED)
7700        return "registered";
7701      if (code == ObservationStatus.PRELIMINARY)
7702        return "preliminary";
7703      if (code == ObservationStatus.FINAL)
7704        return "final";
7705      if (code == ObservationStatus.AMENDED)
7706        return "amended";
7707      if (code == ObservationStatus.CORRECTED)
7708        return "corrected";
7709      if (code == ObservationStatus.CANCELLED)
7710        return "cancelled";
7711      if (code == ObservationStatus.ENTEREDINERROR)
7712        return "entered-in-error";
7713      if (code == ObservationStatus.UNKNOWN)
7714        return "unknown";
7715      return "?";
7716      }
7717    public String toSystem(ObservationStatus code) {
7718      return code.getSystem();
7719      }
7720    }
7721
7722    public enum OperationParameterUse {
7723        /**
7724         * This is an input parameter.
7725         */
7726        IN, 
7727        /**
7728         * This is an output parameter.
7729         */
7730        OUT, 
7731        /**
7732         * added to help the parsers
7733         */
7734        NULL;
7735        public static OperationParameterUse fromCode(String codeString) throws FHIRException {
7736            if (codeString == null || "".equals(codeString))
7737                return null;
7738        if ("in".equals(codeString))
7739          return IN;
7740        if ("out".equals(codeString))
7741          return OUT;
7742        throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'");
7743        }
7744        public String toCode() {
7745          switch (this) {
7746            case IN: return "in";
7747            case OUT: return "out";
7748            default: return "?";
7749          }
7750        }
7751        public String getSystem() {
7752          switch (this) {
7753            case IN: return "http://hl7.org/fhir/operation-parameter-use";
7754            case OUT: return "http://hl7.org/fhir/operation-parameter-use";
7755            default: return "?";
7756          }
7757        }
7758        public String getDefinition() {
7759          switch (this) {
7760            case IN: return "This is an input parameter.";
7761            case OUT: return "This is an output parameter.";
7762            default: return "?";
7763          }
7764        }
7765        public String getDisplay() {
7766          switch (this) {
7767            case IN: return "In";
7768            case OUT: return "Out";
7769            default: return "?";
7770          }
7771        }
7772    }
7773
7774  public static class OperationParameterUseEnumFactory implements EnumFactory<OperationParameterUse> {
7775    public OperationParameterUse fromCode(String codeString) throws IllegalArgumentException {
7776      if (codeString == null || "".equals(codeString))
7777            if (codeString == null || "".equals(codeString))
7778                return null;
7779        if ("in".equals(codeString))
7780          return OperationParameterUse.IN;
7781        if ("out".equals(codeString))
7782          return OperationParameterUse.OUT;
7783        throw new IllegalArgumentException("Unknown OperationParameterUse code '"+codeString+"'");
7784        }
7785        public Enumeration<OperationParameterUse> fromType(Base code) throws FHIRException {
7786          if (code == null)
7787            return null;
7788          if (code.isEmpty())
7789            return new Enumeration<OperationParameterUse>(this);
7790          String codeString = ((PrimitiveType) code).asStringValue();
7791          if (codeString == null || "".equals(codeString))
7792            return null;
7793        if ("in".equals(codeString))
7794          return new Enumeration<OperationParameterUse>(this, OperationParameterUse.IN);
7795        if ("out".equals(codeString))
7796          return new Enumeration<OperationParameterUse>(this, OperationParameterUse.OUT);
7797        throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'");
7798        }
7799    public String toCode(OperationParameterUse code) {
7800      if (code == OperationParameterUse.IN)
7801        return "in";
7802      if (code == OperationParameterUse.OUT)
7803        return "out";
7804      return "?";
7805      }
7806    public String toSystem(OperationParameterUse code) {
7807      return code.getSystem();
7808      }
7809    }
7810
7811    public enum ParticipationStatus {
7812        /**
7813         * The participant has accepted the appointment.
7814         */
7815        ACCEPTED, 
7816        /**
7817         * The participant has declined the appointment and will not participate in the appointment.
7818         */
7819        DECLINED, 
7820        /**
7821         * The participant has  tentatively accepted the appointment. This could be automatically created by a system and requires further processing before it can be accepted. There is no commitment that attendance will occur.
7822         */
7823        TENTATIVE, 
7824        /**
7825         * The participant needs to indicate if they accept the appointment by changing this status to one of the other statuses.
7826         */
7827        NEEDSACTION, 
7828        /**
7829         * added to help the parsers
7830         */
7831        NULL;
7832        public static ParticipationStatus fromCode(String codeString) throws FHIRException {
7833            if (codeString == null || "".equals(codeString))
7834                return null;
7835        if ("accepted".equals(codeString))
7836          return ACCEPTED;
7837        if ("declined".equals(codeString))
7838          return DECLINED;
7839        if ("tentative".equals(codeString))
7840          return TENTATIVE;
7841        if ("needs-action".equals(codeString))
7842          return NEEDSACTION;
7843        throw new FHIRException("Unknown ParticipationStatus code '"+codeString+"'");
7844        }
7845        public String toCode() {
7846          switch (this) {
7847            case ACCEPTED: return "accepted";
7848            case DECLINED: return "declined";
7849            case TENTATIVE: return "tentative";
7850            case NEEDSACTION: return "needs-action";
7851            default: return "?";
7852          }
7853        }
7854        public String getSystem() {
7855          switch (this) {
7856            case ACCEPTED: return "http://hl7.org/fhir/participationstatus";
7857            case DECLINED: return "http://hl7.org/fhir/participationstatus";
7858            case TENTATIVE: return "http://hl7.org/fhir/participationstatus";
7859            case NEEDSACTION: return "http://hl7.org/fhir/participationstatus";
7860            default: return "?";
7861          }
7862        }
7863        public String getDefinition() {
7864          switch (this) {
7865            case ACCEPTED: return "The participant has accepted the appointment.";
7866            case DECLINED: return "The participant has declined the appointment and will not participate in the appointment.";
7867            case TENTATIVE: return "The participant has  tentatively accepted the appointment. This could be automatically created by a system and requires further processing before it can be accepted. There is no commitment that attendance will occur.";
7868            case NEEDSACTION: return "The participant needs to indicate if they accept the appointment by changing this status to one of the other statuses.";
7869            default: return "?";
7870          }
7871        }
7872        public String getDisplay() {
7873          switch (this) {
7874            case ACCEPTED: return "Accepted";
7875            case DECLINED: return "Declined";
7876            case TENTATIVE: return "Tentative";
7877            case NEEDSACTION: return "Needs Action";
7878            default: return "?";
7879          }
7880        }
7881    }
7882
7883  public static class ParticipationStatusEnumFactory implements EnumFactory<ParticipationStatus> {
7884    public ParticipationStatus fromCode(String codeString) throws IllegalArgumentException {
7885      if (codeString == null || "".equals(codeString))
7886            if (codeString == null || "".equals(codeString))
7887                return null;
7888        if ("accepted".equals(codeString))
7889          return ParticipationStatus.ACCEPTED;
7890        if ("declined".equals(codeString))
7891          return ParticipationStatus.DECLINED;
7892        if ("tentative".equals(codeString))
7893          return ParticipationStatus.TENTATIVE;
7894        if ("needs-action".equals(codeString))
7895          return ParticipationStatus.NEEDSACTION;
7896        throw new IllegalArgumentException("Unknown ParticipationStatus code '"+codeString+"'");
7897        }
7898        public Enumeration<ParticipationStatus> fromType(Base code) throws FHIRException {
7899          if (code == null)
7900            return null;
7901          if (code.isEmpty())
7902            return new Enumeration<ParticipationStatus>(this);
7903          String codeString = ((PrimitiveType) code).asStringValue();
7904          if (codeString == null || "".equals(codeString))
7905            return null;
7906        if ("accepted".equals(codeString))
7907          return new Enumeration<ParticipationStatus>(this, ParticipationStatus.ACCEPTED);
7908        if ("declined".equals(codeString))
7909          return new Enumeration<ParticipationStatus>(this, ParticipationStatus.DECLINED);
7910        if ("tentative".equals(codeString))
7911          return new Enumeration<ParticipationStatus>(this, ParticipationStatus.TENTATIVE);
7912        if ("needs-action".equals(codeString))
7913          return new Enumeration<ParticipationStatus>(this, ParticipationStatus.NEEDSACTION);
7914        throw new FHIRException("Unknown ParticipationStatus code '"+codeString+"'");
7915        }
7916    public String toCode(ParticipationStatus code) {
7917      if (code == ParticipationStatus.ACCEPTED)
7918        return "accepted";
7919      if (code == ParticipationStatus.DECLINED)
7920        return "declined";
7921      if (code == ParticipationStatus.TENTATIVE)
7922        return "tentative";
7923      if (code == ParticipationStatus.NEEDSACTION)
7924        return "needs-action";
7925      return "?";
7926      }
7927    public String toSystem(ParticipationStatus code) {
7928      return code.getSystem();
7929      }
7930    }
7931
7932    public enum PublicationStatus {
7933        /**
7934         * This resource is still under development and is not yet considered to be ready for normal use.
7935         */
7936        DRAFT, 
7937        /**
7938         * This resource is ready for normal use.
7939         */
7940        ACTIVE, 
7941        /**
7942         * This resource has been withdrawn or superseded and should no longer be used.
7943         */
7944        RETIRED, 
7945        /**
7946         * The authoring system does not know which of the status values currently applies for this resource.  Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, it's just not known which one.
7947         */
7948        UNKNOWN, 
7949        /**
7950         * added to help the parsers
7951         */
7952        NULL;
7953        public static PublicationStatus fromCode(String codeString) throws FHIRException {
7954            if (codeString == null || "".equals(codeString))
7955                return null;
7956        if ("draft".equals(codeString))
7957          return DRAFT;
7958        if ("active".equals(codeString))
7959          return ACTIVE;
7960        if ("retired".equals(codeString))
7961          return RETIRED;
7962        if ("unknown".equals(codeString))
7963          return UNKNOWN;
7964        throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'");
7965        }
7966        public String toCode() {
7967          switch (this) {
7968            case DRAFT: return "draft";
7969            case ACTIVE: return "active";
7970            case RETIRED: return "retired";
7971            case UNKNOWN: return "unknown";
7972            default: return "?";
7973          }
7974        }
7975        public String getSystem() {
7976          switch (this) {
7977            case DRAFT: return "http://hl7.org/fhir/publication-status";
7978            case ACTIVE: return "http://hl7.org/fhir/publication-status";
7979            case RETIRED: return "http://hl7.org/fhir/publication-status";
7980            case UNKNOWN: return "http://hl7.org/fhir/publication-status";
7981            default: return "?";
7982          }
7983        }
7984        public String getDefinition() {
7985          switch (this) {
7986            case DRAFT: return "This resource is still under development and is not yet considered to be ready for normal use.";
7987            case ACTIVE: return "This resource is ready for normal use.";
7988            case RETIRED: return "This resource has been withdrawn or superseded and should no longer be used.";
7989            case UNKNOWN: return "The authoring system does not know which of the status values currently applies for this resource.  Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, it's just not known which one.";
7990            default: return "?";
7991          }
7992        }
7993        public String getDisplay() {
7994          switch (this) {
7995            case DRAFT: return "Draft";
7996            case ACTIVE: return "Active";
7997            case RETIRED: return "Retired";
7998            case UNKNOWN: return "Unknown";
7999            default: return "?";
8000          }
8001        }
8002    }
8003
8004  public static class PublicationStatusEnumFactory implements EnumFactory<PublicationStatus> {
8005    public PublicationStatus fromCode(String codeString) throws IllegalArgumentException {
8006      if (codeString == null || "".equals(codeString))
8007            if (codeString == null || "".equals(codeString))
8008                return null;
8009        if ("draft".equals(codeString))
8010          return PublicationStatus.DRAFT;
8011        if ("active".equals(codeString))
8012          return PublicationStatus.ACTIVE;
8013        if ("retired".equals(codeString))
8014          return PublicationStatus.RETIRED;
8015        if ("unknown".equals(codeString))
8016          return PublicationStatus.UNKNOWN;
8017        throw new IllegalArgumentException("Unknown PublicationStatus code '"+codeString+"'");
8018        }
8019        public Enumeration<PublicationStatus> fromType(Base code) throws FHIRException {
8020          if (code == null)
8021            return null;
8022          if (code.isEmpty())
8023            return new Enumeration<PublicationStatus>(this);
8024          String codeString = ((PrimitiveType) code).asStringValue();
8025          if (codeString == null || "".equals(codeString))
8026            return null;
8027        if ("draft".equals(codeString))
8028          return new Enumeration<PublicationStatus>(this, PublicationStatus.DRAFT);
8029        if ("active".equals(codeString))
8030          return new Enumeration<PublicationStatus>(this, PublicationStatus.ACTIVE);
8031        if ("retired".equals(codeString))
8032          return new Enumeration<PublicationStatus>(this, PublicationStatus.RETIRED);
8033        if ("unknown".equals(codeString))
8034          return new Enumeration<PublicationStatus>(this, PublicationStatus.UNKNOWN);
8035        throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'");
8036        }
8037    public String toCode(PublicationStatus code) {
8038      if (code == PublicationStatus.DRAFT)
8039        return "draft";
8040      if (code == PublicationStatus.ACTIVE)
8041        return "active";
8042      if (code == PublicationStatus.RETIRED)
8043        return "retired";
8044      if (code == PublicationStatus.UNKNOWN)
8045        return "unknown";
8046      return "?";
8047      }
8048    public String toSystem(PublicationStatus code) {
8049      return code.getSystem();
8050      }
8051    }
8052
8053    public enum QuantityComparator {
8054        /**
8055         * The actual value is less than the given value.
8056         */
8057        LESS_THAN, 
8058        /**
8059         * The actual value is less than or equal to the given value.
8060         */
8061        LESS_OR_EQUAL, 
8062        /**
8063         * The actual value is greater than or equal to the given value.
8064         */
8065        GREATER_OR_EQUAL, 
8066        /**
8067         * The actual value is greater than the given value.
8068         */
8069        GREATER_THAN, 
8070        /**
8071         * added to help the parsers
8072         */
8073        NULL;
8074        public static QuantityComparator fromCode(String codeString) throws FHIRException {
8075            if (codeString == null || "".equals(codeString))
8076                return null;
8077        if ("<".equals(codeString))
8078          return LESS_THAN;
8079        if ("<=".equals(codeString))
8080          return LESS_OR_EQUAL;
8081        if (">=".equals(codeString))
8082          return GREATER_OR_EQUAL;
8083        if (">".equals(codeString))
8084          return GREATER_THAN;
8085        throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'");
8086        }
8087        public String toCode() {
8088          switch (this) {
8089            case LESS_THAN: return "<";
8090            case LESS_OR_EQUAL: return "<=";
8091            case GREATER_OR_EQUAL: return ">=";
8092            case GREATER_THAN: return ">";
8093            default: return "?";
8094          }
8095        }
8096        public String getSystem() {
8097          switch (this) {
8098            case LESS_THAN: return "http://hl7.org/fhir/quantity-comparator";
8099            case LESS_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator";
8100            case GREATER_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator";
8101            case GREATER_THAN: return "http://hl7.org/fhir/quantity-comparator";
8102            default: return "?";
8103          }
8104        }
8105        public String getDefinition() {
8106          switch (this) {
8107            case LESS_THAN: return "The actual value is less than the given value.";
8108            case LESS_OR_EQUAL: return "The actual value is less than or equal to the given value.";
8109            case GREATER_OR_EQUAL: return "The actual value is greater than or equal to the given value.";
8110            case GREATER_THAN: return "The actual value is greater than the given value.";
8111            default: return "?";
8112          }
8113        }
8114        public String getDisplay() {
8115          switch (this) {
8116            case LESS_THAN: return "Less than";
8117            case LESS_OR_EQUAL: return "Less or Equal to";
8118            case GREATER_OR_EQUAL: return "Greater or Equal to";
8119            case GREATER_THAN: return "Greater than";
8120            default: return "?";
8121          }
8122        }
8123    }
8124
8125  public static class QuantityComparatorEnumFactory implements EnumFactory<QuantityComparator> {
8126    public QuantityComparator fromCode(String codeString) throws IllegalArgumentException {
8127      if (codeString == null || "".equals(codeString))
8128            if (codeString == null || "".equals(codeString))
8129                return null;
8130        if ("<".equals(codeString))
8131          return QuantityComparator.LESS_THAN;
8132        if ("<=".equals(codeString))
8133          return QuantityComparator.LESS_OR_EQUAL;
8134        if (">=".equals(codeString))
8135          return QuantityComparator.GREATER_OR_EQUAL;
8136        if (">".equals(codeString))
8137          return QuantityComparator.GREATER_THAN;
8138        throw new IllegalArgumentException("Unknown QuantityComparator code '"+codeString+"'");
8139        }
8140        public Enumeration<QuantityComparator> fromType(Base code) throws FHIRException {
8141          if (code == null)
8142            return null;
8143          if (code.isEmpty())
8144            return new Enumeration<QuantityComparator>(this);
8145          String codeString = ((PrimitiveType) code).asStringValue();
8146          if (codeString == null || "".equals(codeString))
8147            return null;
8148        if ("<".equals(codeString))
8149          return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_THAN);
8150        if ("<=".equals(codeString))
8151          return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_OR_EQUAL);
8152        if (">=".equals(codeString))
8153          return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_OR_EQUAL);
8154        if (">".equals(codeString))
8155          return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_THAN);
8156        throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'");
8157        }
8158    public String toCode(QuantityComparator code) {
8159      if (code == QuantityComparator.LESS_THAN)
8160        return "<";
8161      if (code == QuantityComparator.LESS_OR_EQUAL)
8162        return "<=";
8163      if (code == QuantityComparator.GREATER_OR_EQUAL)
8164        return ">=";
8165      if (code == QuantityComparator.GREATER_THAN)
8166        return ">";
8167      return "?";
8168      }
8169    public String toSystem(QuantityComparator code) {
8170      return code.getSystem();
8171      }
8172    }
8173
8174    public enum RequestIntent {
8175        /**
8176         * The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act.
8177         */
8178        PROPOSAL, 
8179        /**
8180         * The request represents an intention to ensure something occurs without providing an authorization for others to act.
8181         */
8182        PLAN, 
8183        /**
8184         * The request represents a legally binding instruction authored by a Patient or RelatedPerson.
8185         */
8186        DIRECTIVE, 
8187        /**
8188         * The request represents a request/demand and authorization for action by a Practitioner.
8189         */
8190        ORDER, 
8191        /**
8192         * The request represents an original authorization for action.
8193         */
8194        ORIGINALORDER, 
8195        /**
8196         * The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization.
8197         */
8198        REFLEXORDER, 
8199        /**
8200         * The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order.
8201         */
8202        FILLERORDER, 
8203        /**
8204         * An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence.  E.g. The administration of a single dose of a drug.
8205         */
8206        INSTANCEORDER, 
8207        /**
8208         * The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests.  Refer to [[[RequestGroup]]] for additional information on how this status is used.
8209         */
8210        OPTION, 
8211        /**
8212         * added to help the parsers
8213         */
8214        NULL;
8215        public static RequestIntent fromCode(String codeString) throws FHIRException {
8216            if (codeString == null || "".equals(codeString))
8217                return null;
8218        if ("proposal".equals(codeString))
8219          return PROPOSAL;
8220        if ("plan".equals(codeString))
8221          return PLAN;
8222        if ("directive".equals(codeString))
8223          return DIRECTIVE;
8224        if ("order".equals(codeString))
8225          return ORDER;
8226        if ("original-order".equals(codeString))
8227          return ORIGINALORDER;
8228        if ("reflex-order".equals(codeString))
8229          return REFLEXORDER;
8230        if ("filler-order".equals(codeString))
8231          return FILLERORDER;
8232        if ("instance-order".equals(codeString))
8233          return INSTANCEORDER;
8234        if ("option".equals(codeString))
8235          return OPTION;
8236        throw new FHIRException("Unknown RequestIntent code '"+codeString+"'");
8237        }
8238        public String toCode() {
8239          switch (this) {
8240            case PROPOSAL: return "proposal";
8241            case PLAN: return "plan";
8242            case DIRECTIVE: return "directive";
8243            case ORDER: return "order";
8244            case ORIGINALORDER: return "original-order";
8245            case REFLEXORDER: return "reflex-order";
8246            case FILLERORDER: return "filler-order";
8247            case INSTANCEORDER: return "instance-order";
8248            case OPTION: return "option";
8249            default: return "?";
8250          }
8251        }
8252        public String getSystem() {
8253          switch (this) {
8254            case PROPOSAL: return "http://hl7.org/fhir/request-intent";
8255            case PLAN: return "http://hl7.org/fhir/request-intent";
8256            case DIRECTIVE: return "http://hl7.org/fhir/request-intent";
8257            case ORDER: return "http://hl7.org/fhir/request-intent";
8258            case ORIGINALORDER: return "http://hl7.org/fhir/request-intent";
8259            case REFLEXORDER: return "http://hl7.org/fhir/request-intent";
8260            case FILLERORDER: return "http://hl7.org/fhir/request-intent";
8261            case INSTANCEORDER: return "http://hl7.org/fhir/request-intent";
8262            case OPTION: return "http://hl7.org/fhir/request-intent";
8263            default: return "?";
8264          }
8265        }
8266        public String getDefinition() {
8267          switch (this) {
8268            case PROPOSAL: return "The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act.";
8269            case PLAN: return "The request represents an intention to ensure something occurs without providing an authorization for others to act.";
8270            case DIRECTIVE: return "The request represents a legally binding instruction authored by a Patient or RelatedPerson.";
8271            case ORDER: return "The request represents a request/demand and authorization for action by a Practitioner.";
8272            case ORIGINALORDER: return "The request represents an original authorization for action.";
8273            case REFLEXORDER: return "The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization.";
8274            case FILLERORDER: return "The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order.";
8275            case INSTANCEORDER: return "An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence.  E.g. The administration of a single dose of a drug.";
8276            case OPTION: return "The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests.  Refer to [[[RequestGroup]]] for additional information on how this status is used.";
8277            default: return "?";
8278          }
8279        }
8280        public String getDisplay() {
8281          switch (this) {
8282            case PROPOSAL: return "Proposal";
8283            case PLAN: return "Plan";
8284            case DIRECTIVE: return "Directive";
8285            case ORDER: return "Order";
8286            case ORIGINALORDER: return "Original Order";
8287            case REFLEXORDER: return "Reflex Order";
8288            case FILLERORDER: return "Filler Order";
8289            case INSTANCEORDER: return "Instance Order";
8290            case OPTION: return "Option";
8291            default: return "?";
8292          }
8293        }
8294    }
8295
8296  public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> {
8297    public RequestIntent fromCode(String codeString) throws IllegalArgumentException {
8298      if (codeString == null || "".equals(codeString))
8299            if (codeString == null || "".equals(codeString))
8300                return null;
8301        if ("proposal".equals(codeString))
8302          return RequestIntent.PROPOSAL;
8303        if ("plan".equals(codeString))
8304          return RequestIntent.PLAN;
8305        if ("directive".equals(codeString))
8306          return RequestIntent.DIRECTIVE;
8307        if ("order".equals(codeString))
8308          return RequestIntent.ORDER;
8309        if ("original-order".equals(codeString))
8310          return RequestIntent.ORIGINALORDER;
8311        if ("reflex-order".equals(codeString))
8312          return RequestIntent.REFLEXORDER;
8313        if ("filler-order".equals(codeString))
8314          return RequestIntent.FILLERORDER;
8315        if ("instance-order".equals(codeString))
8316          return RequestIntent.INSTANCEORDER;
8317        if ("option".equals(codeString))
8318          return RequestIntent.OPTION;
8319        throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'");
8320        }
8321        public Enumeration<RequestIntent> fromType(Base code) throws FHIRException {
8322          if (code == null)
8323            return null;
8324          if (code.isEmpty())
8325            return new Enumeration<RequestIntent>(this);
8326          String codeString = ((PrimitiveType) code).asStringValue();
8327          if (codeString == null || "".equals(codeString))
8328            return null;
8329        if ("proposal".equals(codeString))
8330          return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL);
8331        if ("plan".equals(codeString))
8332          return new Enumeration<RequestIntent>(this, RequestIntent.PLAN);
8333        if ("directive".equals(codeString))
8334          return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE);
8335        if ("order".equals(codeString))
8336          return new Enumeration<RequestIntent>(this, RequestIntent.ORDER);
8337        if ("original-order".equals(codeString))
8338          return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER);
8339        if ("reflex-order".equals(codeString))
8340          return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER);
8341        if ("filler-order".equals(codeString))
8342          return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER);
8343        if ("instance-order".equals(codeString))
8344          return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER);
8345        if ("option".equals(codeString))
8346          return new Enumeration<RequestIntent>(this, RequestIntent.OPTION);
8347        throw new FHIRException("Unknown RequestIntent code '"+codeString+"'");
8348        }
8349    public String toCode(RequestIntent code) {
8350      if (code == RequestIntent.PROPOSAL)
8351        return "proposal";
8352      if (code == RequestIntent.PLAN)
8353        return "plan";
8354      if (code == RequestIntent.DIRECTIVE)
8355        return "directive";
8356      if (code == RequestIntent.ORDER)
8357        return "order";
8358      if (code == RequestIntent.ORIGINALORDER)
8359        return "original-order";
8360      if (code == RequestIntent.REFLEXORDER)
8361        return "reflex-order";
8362      if (code == RequestIntent.FILLERORDER)
8363        return "filler-order";
8364      if (code == RequestIntent.INSTANCEORDER)
8365        return "instance-order";
8366      if (code == RequestIntent.OPTION)
8367        return "option";
8368      return "?";
8369      }
8370    public String toSystem(RequestIntent code) {
8371      return code.getSystem();
8372      }
8373    }
8374
8375    public enum RequestPriority {
8376        /**
8377         * The request has normal priority.
8378         */
8379        ROUTINE, 
8380        /**
8381         * The request should be actioned promptly - higher priority than routine.
8382         */
8383        URGENT, 
8384        /**
8385         * The request should be actioned as soon as possible - higher priority than urgent.
8386         */
8387        ASAP, 
8388        /**
8389         * The request should be actioned immediately - highest possible priority.  E.g. an emergency.
8390         */
8391        STAT, 
8392        /**
8393         * added to help the parsers
8394         */
8395        NULL;
8396        public static RequestPriority fromCode(String codeString) throws FHIRException {
8397            if (codeString == null || "".equals(codeString))
8398                return null;
8399        if ("routine".equals(codeString))
8400          return ROUTINE;
8401        if ("urgent".equals(codeString))
8402          return URGENT;
8403        if ("asap".equals(codeString))
8404          return ASAP;
8405        if ("stat".equals(codeString))
8406          return STAT;
8407        throw new FHIRException("Unknown RequestPriority code '"+codeString+"'");
8408        }
8409        public String toCode() {
8410          switch (this) {
8411            case ROUTINE: return "routine";
8412            case URGENT: return "urgent";
8413            case ASAP: return "asap";
8414            case STAT: return "stat";
8415            default: return "?";
8416          }
8417        }
8418        public String getSystem() {
8419          switch (this) {
8420            case ROUTINE: return "http://hl7.org/fhir/request-priority";
8421            case URGENT: return "http://hl7.org/fhir/request-priority";
8422            case ASAP: return "http://hl7.org/fhir/request-priority";
8423            case STAT: return "http://hl7.org/fhir/request-priority";
8424            default: return "?";
8425          }
8426        }
8427        public String getDefinition() {
8428          switch (this) {
8429            case ROUTINE: return "The request has normal priority.";
8430            case URGENT: return "The request should be actioned promptly - higher priority than routine.";
8431            case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent.";
8432            case STAT: return "The request should be actioned immediately - highest possible priority.  E.g. an emergency.";
8433            default: return "?";
8434          }
8435        }
8436        public String getDisplay() {
8437          switch (this) {
8438            case ROUTINE: return "Routine";
8439            case URGENT: return "Urgent";
8440            case ASAP: return "ASAP";
8441            case STAT: return "STAT";
8442            default: return "?";
8443          }
8444        }
8445    }
8446
8447  public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> {
8448    public RequestPriority fromCode(String codeString) throws IllegalArgumentException {
8449      if (codeString == null || "".equals(codeString))
8450            if (codeString == null || "".equals(codeString))
8451                return null;
8452        if ("routine".equals(codeString))
8453          return RequestPriority.ROUTINE;
8454        if ("urgent".equals(codeString))
8455          return RequestPriority.URGENT;
8456        if ("asap".equals(codeString))
8457          return RequestPriority.ASAP;
8458        if ("stat".equals(codeString))
8459          return RequestPriority.STAT;
8460        throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'");
8461        }
8462        public Enumeration<RequestPriority> fromType(Base code) throws FHIRException {
8463          if (code == null)
8464            return null;
8465          if (code.isEmpty())
8466            return new Enumeration<RequestPriority>(this);
8467          String codeString = ((PrimitiveType) code).asStringValue();
8468          if (codeString == null || "".equals(codeString))
8469            return null;
8470        if ("routine".equals(codeString))
8471          return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE);
8472        if ("urgent".equals(codeString))
8473          return new Enumeration<RequestPriority>(this, RequestPriority.URGENT);
8474        if ("asap".equals(codeString))
8475          return new Enumeration<RequestPriority>(this, RequestPriority.ASAP);
8476        if ("stat".equals(codeString))
8477          return new Enumeration<RequestPriority>(this, RequestPriority.STAT);
8478        throw new FHIRException("Unknown RequestPriority code '"+codeString+"'");
8479        }
8480    public String toCode(RequestPriority code) {
8481      if (code == RequestPriority.ROUTINE)
8482        return "routine";
8483      if (code == RequestPriority.URGENT)
8484        return "urgent";
8485      if (code == RequestPriority.ASAP)
8486        return "asap";
8487      if (code == RequestPriority.STAT)
8488        return "stat";
8489      return "?";
8490      }
8491    public String toSystem(RequestPriority code) {
8492      return code.getSystem();
8493      }
8494    }
8495
8496    public enum RequestStatus {
8497        /**
8498         * The request has been created but is not yet complete or ready for action.
8499         */
8500        DRAFT, 
8501        /**
8502         * The request is in force and ready to be acted upon.
8503         */
8504        ACTIVE, 
8505        /**
8506         * The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future.
8507         */
8508        ONHOLD, 
8509        /**
8510         * The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions.  No further activity should occur.
8511         */
8512        REVOKED, 
8513        /**
8514         * The activity described by the request has been fully performed.  No further activity will occur.
8515         */
8516        COMPLETED, 
8517        /**
8518         * This request should never have existed and should be considered 'void'.  (It is possible that real-world decisions were based on it.  If real-world activity has occurred, the status should be "revoked" rather than "entered-in-error".).
8519         */
8520        ENTEREDINERROR, 
8521        /**
8522         * The authoring/source system does not know which of the status values currently applies for this request.  Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply,  but the authoring/source system does not know which.
8523         */
8524        UNKNOWN, 
8525        /**
8526         * added to help the parsers
8527         */
8528        NULL;
8529        public static RequestStatus fromCode(String codeString) throws FHIRException {
8530            if (codeString == null || "".equals(codeString))
8531                return null;
8532        if ("draft".equals(codeString))
8533          return DRAFT;
8534        if ("active".equals(codeString))
8535          return ACTIVE;
8536        if ("on-hold".equals(codeString))
8537          return ONHOLD;
8538        if ("revoked".equals(codeString))
8539          return REVOKED;
8540        if ("completed".equals(codeString))
8541          return COMPLETED;
8542        if ("entered-in-error".equals(codeString))
8543          return ENTEREDINERROR;
8544        if ("unknown".equals(codeString))
8545          return UNKNOWN;
8546        throw new FHIRException("Unknown RequestStatus code '"+codeString+"'");
8547        }
8548        public String toCode() {
8549          switch (this) {
8550            case DRAFT: return "draft";
8551            case ACTIVE: return "active";
8552            case ONHOLD: return "on-hold";
8553            case REVOKED: return "revoked";
8554            case COMPLETED: return "completed";
8555            case ENTEREDINERROR: return "entered-in-error";
8556            case UNKNOWN: return "unknown";
8557            default: return "?";
8558          }
8559        }
8560        public String getSystem() {
8561          switch (this) {
8562            case DRAFT: return "http://hl7.org/fhir/request-status";
8563            case ACTIVE: return "http://hl7.org/fhir/request-status";
8564            case ONHOLD: return "http://hl7.org/fhir/request-status";
8565            case REVOKED: return "http://hl7.org/fhir/request-status";
8566            case COMPLETED: return "http://hl7.org/fhir/request-status";
8567            case ENTEREDINERROR: return "http://hl7.org/fhir/request-status";
8568            case UNKNOWN: return "http://hl7.org/fhir/request-status";
8569            default: return "?";
8570          }
8571        }
8572        public String getDefinition() {
8573          switch (this) {
8574            case DRAFT: return "The request has been created but is not yet complete or ready for action.";
8575            case ACTIVE: return "The request is in force and ready to be acted upon.";
8576            case ONHOLD: return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future.";
8577            case REVOKED: return "The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions.  No further activity should occur.";
8578            case COMPLETED: return "The activity described by the request has been fully performed.  No further activity will occur.";
8579            case ENTEREDINERROR: return "This request should never have existed and should be considered 'void'.  (It is possible that real-world decisions were based on it.  If real-world activity has occurred, the status should be \"revoked\" rather than \"entered-in-error\".).";
8580            case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this request.  Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply,  but the authoring/source system does not know which.";
8581            default: return "?";
8582          }
8583        }
8584        public String getDisplay() {
8585          switch (this) {
8586            case DRAFT: return "Draft";
8587            case ACTIVE: return "Active";
8588            case ONHOLD: return "On Hold";
8589            case REVOKED: return "Revoked";
8590            case COMPLETED: return "Completed";
8591            case ENTEREDINERROR: return "Entered in Error";
8592            case UNKNOWN: return "Unknown";
8593            default: return "?";
8594          }
8595        }
8596    }
8597
8598  public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> {
8599    public RequestStatus fromCode(String codeString) throws IllegalArgumentException {
8600      if (codeString == null || "".equals(codeString))
8601            if (codeString == null || "".equals(codeString))
8602                return null;
8603        if ("draft".equals(codeString))
8604          return RequestStatus.DRAFT;
8605        if ("active".equals(codeString))
8606          return RequestStatus.ACTIVE;
8607        if ("on-hold".equals(codeString))
8608          return RequestStatus.ONHOLD;
8609        if ("revoked".equals(codeString))
8610          return RequestStatus.REVOKED;
8611        if ("completed".equals(codeString))
8612          return RequestStatus.COMPLETED;
8613        if ("entered-in-error".equals(codeString))
8614          return RequestStatus.ENTEREDINERROR;
8615        if ("unknown".equals(codeString))
8616          return RequestStatus.UNKNOWN;
8617        throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'");
8618        }
8619        public Enumeration<RequestStatus> fromType(Base code) throws FHIRException {
8620          if (code == null)
8621            return null;
8622          if (code.isEmpty())
8623            return new Enumeration<RequestStatus>(this);
8624          String codeString = ((PrimitiveType) code).asStringValue();
8625          if (codeString == null || "".equals(codeString))
8626            return null;
8627        if ("draft".equals(codeString))
8628          return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT);
8629        if ("active".equals(codeString))
8630          return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE);
8631        if ("on-hold".equals(codeString))
8632          return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD);
8633        if ("revoked".equals(codeString))
8634          return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED);
8635        if ("completed".equals(codeString))
8636          return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED);
8637        if ("entered-in-error".equals(codeString))
8638          return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR);
8639        if ("unknown".equals(codeString))
8640          return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN);
8641        throw new FHIRException("Unknown RequestStatus code '"+codeString+"'");
8642        }
8643    public String toCode(RequestStatus code) {
8644      if (code == RequestStatus.DRAFT)
8645        return "draft";
8646      if (code == RequestStatus.ACTIVE)
8647        return "active";
8648      if (code == RequestStatus.ONHOLD)
8649        return "on-hold";
8650      if (code == RequestStatus.REVOKED)
8651        return "revoked";
8652      if (code == RequestStatus.COMPLETED)
8653        return "completed";
8654      if (code == RequestStatus.ENTEREDINERROR)
8655        return "entered-in-error";
8656      if (code == RequestStatus.UNKNOWN)
8657        return "unknown";
8658      return "?";
8659      }
8660    public String toSystem(RequestStatus code) {
8661      return code.getSystem();
8662      }
8663    }
8664
8665    public enum ResourceTypeEnum {
8666        /**
8667         * 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.
8668         */
8669        ACCOUNT, 
8670        /**
8671         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
8672         */
8673        ACTIVITYDEFINITION, 
8674        /**
8675         * A pharmaceutical product described in terms of its composition and dose form.
8676         */
8677        ADMINISTRABLEPRODUCTDEFINITION, 
8678        /**
8679         * An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject.  The unintended effects may require additional monitoring, treatment or hospitalization or may result in death.  The AdverseEvent resource also extends to potential or avoided events that could have had such effects.
8680         */
8681        ADVERSEEVENT, 
8682        /**
8683         * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.
8684         */
8685        ALLERGYINTOLERANCE, 
8686        /**
8687         * 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).
8688         */
8689        APPOINTMENT, 
8690        /**
8691         * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.
8692         */
8693        APPOINTMENTRESPONSE, 
8694        /**
8695         * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis.
8696         */
8697        AUDITEVENT, 
8698        /**
8699         * 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.
8700         */
8701        BASIC, 
8702        /**
8703         * 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.
8704         */
8705        BINARY, 
8706        /**
8707         * A material substance originating from a biological entity intended to be transplanted or infused
8708into another (possibly the same) biological entity.
8709         */
8710        BIOLOGICALLYDERIVEDPRODUCT, 
8711        /**
8712         * 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.
8713         */
8714        BODYSTRUCTURE, 
8715        /**
8716         * A container for a collection of resources.
8717         */
8718        BUNDLE, 
8719        /**
8720         * 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.
8721         */
8722        CAPABILITYSTATEMENT, 
8723        /**
8724         * 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.
8725         */
8726        CAPABILITYSTATEMENT2, 
8727        /**
8728         * 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.
8729         */
8730        CAREPLAN, 
8731        /**
8732         * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care.
8733         */
8734        CARETEAM, 
8735        /**
8736         * Catalog entries are wrappers that contextualize items included in a catalog.
8737         */
8738        CATALOGENTRY, 
8739        /**
8740         * 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.
8741         */
8742        CHARGEITEM, 
8743        /**
8744         * 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.
8745         */
8746        CHARGEITEMDEFINITION, 
8747        /**
8748         * 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.
8749         */
8750        CLAIM, 
8751        /**
8752         * This resource provides the adjudication details from the processing of a Claim resource.
8753         */
8754        CLAIMRESPONSE, 
8755        /**
8756         * 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.
8757         */
8758        CLINICALIMPRESSION, 
8759        /**
8760         * A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure.
8761         */
8762        CLINICALUSEISSUE, 
8763        /**
8764         * 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.
8765         */
8766        CODESYSTEM, 
8767        /**
8768         * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition.
8769         */
8770        COMMUNICATION, 
8771        /**
8772         * 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.
8773         */
8774        COMMUNICATIONREQUEST, 
8775        /**
8776         * A compartment definition that defines how resources are accessed on a server.
8777         */
8778        COMPARTMENTDEFINITION, 
8779        /**
8780         * 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.).
8781         */
8782        COMPOSITION, 
8783        /**
8784         * 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.
8785         */
8786        CONCEPTMAP, 
8787        /**
8788         * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.
8789         */
8790        CONDITION, 
8791        /**
8792         * A definition of a condition and information relevant to managing it.
8793         */
8794        CONDITIONDEFINITION, 
8795        /**
8796         * A record of a healthcare consumer’s  choices  or choices made on their behalf by a third party, 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.
8797         */
8798        CONSENT, 
8799        /**
8800         * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
8801         */
8802        CONTRACT, 
8803        /**
8804         * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.
8805         */
8806        COVERAGE, 
8807        /**
8808         * 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.
8809         */
8810        COVERAGEELIGIBILITYREQUEST, 
8811        /**
8812         * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.
8813         */
8814        COVERAGEELIGIBILITYRESPONSE, 
8815        /**
8816         * 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.
8817         */
8818        DETECTEDISSUE, 
8819        /**
8820         * 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.
8821         */
8822        DEVICE, 
8823        /**
8824         * The characteristics, operational status and capabilities of a medical-related component of a medical device.
8825         */
8826        DEVICEDEFINITION, 
8827        /**
8828         * Describes a measurement, calculation or setting capability of a medical device.
8829         */
8830        DEVICEMETRIC, 
8831        /**
8832         * 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.
8833         */
8834        DEVICEREQUEST, 
8835        /**
8836         * 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.
8837         */
8838        DEVICEUSESTATEMENT, 
8839        /**
8840         * 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.
8841         */
8842        DIAGNOSTICREPORT, 
8843        /**
8844         * A collection of documents compiled for a purpose together with metadata that applies to the collection.
8845         */
8846        DOCUMENTMANIFEST, 
8847        /**
8848         * A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this "document" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare.  The DocumentReference resource provides metadata about the document so that the document can be discovered and managed.  The actual content may be inline base64 encoded data or provided by direct reference.
8849         */
8850        DOCUMENTREFERENCE, 
8851        /**
8852         * A resource that includes narrative, extensions, and contained resources.
8853         */
8854        DOMAINRESOURCE, 
8855        /**
8856         * 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.
8857         */
8858        ENCOUNTER, 
8859        /**
8860         * 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.
8861         */
8862        ENDPOINT, 
8863        /**
8864         * This resource provides the insurance enrollment details to the insurer regarding a specified coverage.
8865         */
8866        ENROLLMENTREQUEST, 
8867        /**
8868         * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.
8869         */
8870        ENROLLMENTRESPONSE, 
8871        /**
8872         * 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.
8873         */
8874        EPISODEOFCARE, 
8875        /**
8876         * The EventDefinition resource provides a reusable description of when a particular event can occur.
8877         */
8878        EVENTDEFINITION, 
8879        /**
8880         * This represents statistics, certainty, both the intended and actual population, and evidence variables.
8881         */
8882        EVIDENCE, 
8883        /**
8884         * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about.
8885         */
8886        EVIDENCEVARIABLE, 
8887        /**
8888         * Example of workflow instance.
8889         */
8890        EXAMPLESCENARIO, 
8891        /**
8892         * 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.
8893         */
8894        EXPLANATIONOFBENEFIT, 
8895        /**
8896         * Significant health conditions for a person related to the patient relevant in the context of care for the patient.
8897         */
8898        FAMILYMEMBERHISTORY, 
8899        /**
8900         * Prospective warnings of potential issues when providing care to the patient.
8901         */
8902        FLAG, 
8903        /**
8904         * 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.
8905         */
8906        GOAL, 
8907        /**
8908         * 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.
8909         */
8910        GRAPHDEFINITION, 
8911        /**
8912         * 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.
8913         */
8914        GROUP, 
8915        /**
8916         * 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.
8917         */
8918        GUIDANCERESPONSE, 
8919        /**
8920         * The details of a healthcare service available at a location.
8921         */
8922        HEALTHCARESERVICE, 
8923        /**
8924         * 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.
8925         */
8926        IMAGINGSTUDY, 
8927        /**
8928         * 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.
8929         */
8930        IMMUNIZATION, 
8931        /**
8932         * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations.
8933         */
8934        IMMUNIZATIONEVALUATION, 
8935        /**
8936         * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.
8937         */
8938        IMMUNIZATIONRECOMMENDATION, 
8939        /**
8940         * 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.
8941         */
8942        IMPLEMENTATIONGUIDE, 
8943        /**
8944         * An ingredient of a manufactured item or pharmaceutical product.
8945         */
8946        INGREDIENT, 
8947        /**
8948         * Details of a Health Insurance product/plan provided by an organization.
8949         */
8950        INSURANCEPLAN, 
8951        /**
8952         * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.
8953         */
8954        INVOICE, 
8955        /**
8956         * 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.
8957         */
8958        LIBRARY, 
8959        /**
8960         * Identifies two or more records (resource instances) that refer to the same real-world "occurrence".
8961         */
8962        LINKAGE, 
8963        /**
8964         * A list is a curated collection of resources.
8965         */
8966        LIST, 
8967        /**
8968         * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated.
8969         */
8970        LOCATION, 
8971        /**
8972         * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product.
8973         */
8974        MANUFACTUREDITEMDEFINITION, 
8975        /**
8976         * The Measure resource provides the definition of a quality measure.
8977         */
8978        MEASURE, 
8979        /**
8980         * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.
8981         */
8982        MEASUREREPORT, 
8983        /**
8984         * 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.
8985         */
8986        MEDICATION, 
8987        /**
8988         * 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.
8989         */
8990        MEDICATIONADMINISTRATION, 
8991        /**
8992         * 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.
8993         */
8994        MEDICATIONDISPENSE, 
8995        /**
8996         * Information about a medication that is used to support knowledge.
8997         */
8998        MEDICATIONKNOWLEDGE, 
8999        /**
9000         * 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.
9001         */
9002        MEDICATIONREQUEST, 
9003        /**
9004         * A record of a medication that is being consumed by a patient.   A MedicationUsage 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. 
9005
9006The primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medicationusage 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 Usage 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.
9007         */
9008        MEDICATIONUSAGE, 
9009        /**
9010         * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).
9011         */
9012        MEDICINALPRODUCTDEFINITION, 
9013        /**
9014         * 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.
9015         */
9016        MESSAGEDEFINITION, 
9017        /**
9018         * 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.
9019         */
9020        MESSAGEHEADER, 
9021        /**
9022         * Raw data describing a biological sequence.
9023         */
9024        MOLECULARSEQUENCE, 
9025        /**
9026         * 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.
9027         */
9028        NAMINGSYSTEM, 
9029        /**
9030         * A record of food or fluid that is being consumed by a patient.   A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past.  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 or through an app that tracks food or fluids consumed.   The consumption information may come from sources such as the patient's memory, from a nutrition label,  or from a clinician documenting observed intake.
9031         */
9032        NUTRITIONINTAKE, 
9033        /**
9034         * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.
9035         */
9036        NUTRITIONORDER, 
9037        /**
9038         * Measurements and simple assertions made about a patient, device or other subject.
9039         */
9040        OBSERVATION, 
9041        /**
9042         * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.
9043         */
9044        OBSERVATIONDEFINITION, 
9045        /**
9046         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
9047         */
9048        OPERATIONDEFINITION, 
9049        /**
9050         * A collection of error, warning, or information messages that result from a system action.
9051         */
9052        OPERATIONOUTCOME, 
9053        /**
9054         * 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.
9055         */
9056        ORGANIZATION, 
9057        /**
9058         * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.
9059         */
9060        ORGANIZATIONAFFILIATION, 
9061        /**
9062         * A medicinal product in a container or package.
9063         */
9064        PACKAGEDPRODUCTDEFINITION, 
9065        /**
9066         * 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.
9067         */
9068        PARAMETERS, 
9069        /**
9070         * Demographics and other administrative information about an individual or animal receiving care or other health-related services.
9071         */
9072        PATIENT, 
9073        /**
9074         * This resource provides the status of the payment for goods and services rendered, and the request and response resource references.
9075         */
9076        PAYMENTNOTICE, 
9077        /**
9078         * This resource provides the details including amount of a payment and allocates the payment items being paid.
9079         */
9080        PAYMENTRECONCILIATION, 
9081        /**
9082         * Demographics and administrative information about a person independent of a specific health-related context.
9083         */
9084        PERSON, 
9085        /**
9086         * 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.
9087         */
9088        PLANDEFINITION, 
9089        /**
9090         * A person who is directly or indirectly involved in the provisioning of healthcare.
9091         */
9092        PRACTITIONER, 
9093        /**
9094         * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.
9095         */
9096        PRACTITIONERROLE, 
9097        /**
9098         * 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.
9099         */
9100        PROCEDURE, 
9101        /**
9102         * 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.
9103         */
9104        PROVENANCE, 
9105        /**
9106         * 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.
9107         */
9108        QUESTIONNAIRE, 
9109        /**
9110         * 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.
9111         */
9112        QUESTIONNAIRERESPONSE, 
9113        /**
9114         * The regulatory authorization of a medicinal product.
9115         */
9116        REGULATEDAUTHORIZATION, 
9117        /**
9118         * 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.
9119         */
9120        RELATEDPERSON, 
9121        /**
9122         * 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".
9123         */
9124        REQUESTGROUP, 
9125        /**
9126         * 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.
9127         */
9128        RESEARCHSTUDY, 
9129        /**
9130         * A physical entity which is the primary unit of operational and/or administrative interest in a study.
9131         */
9132        RESEARCHSUBJECT, 
9133        /**
9134         * This is the base resource type for everything.
9135         */
9136        RESOURCE, 
9137        /**
9138         * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.
9139         */
9140        RISKASSESSMENT, 
9141        /**
9142         * A container for slots of time that may be available for booking appointments.
9143         */
9144        SCHEDULE, 
9145        /**
9146         * A search parameter that defines a named search item that can be used to search/filter on a resource.
9147         */
9148        SEARCHPARAMETER, 
9149        /**
9150         * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.
9151         */
9152        SERVICEREQUEST, 
9153        /**
9154         * A slot of time on a schedule that may be available for booking appointments.
9155         */
9156        SLOT, 
9157        /**
9158         * A sample to be used for analysis.
9159         */
9160        SPECIMEN, 
9161        /**
9162         * A kind of specimen with associated set of requirements.
9163         */
9164        SPECIMENDEFINITION, 
9165        /**
9166         * 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.
9167         */
9168        STRUCTUREDEFINITION, 
9169        /**
9170         * A Map of relationships between 2 structures that can be used to transform data.
9171         */
9172        STRUCTUREMAP, 
9173        /**
9174         * The subscription resource describes a particular client's request to be notified about a Topic.
9175         */
9176        SUBSCRIPTION, 
9177        /**
9178         * A homogeneous material with a definite composition.
9179         */
9180        SUBSTANCE, 
9181        /**
9182         * The detailed description of a substance, typically at a level beyond what is used for prescribing.
9183         */
9184        SUBSTANCEDEFINITION, 
9185        /**
9186         * 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.
9187         */
9188        SUBSTANCENUCLEICACID, 
9189        /**
9190         * Todo.
9191         */
9192        SUBSTANCEPOLYMER, 
9193        /**
9194         * 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.
9195         */
9196        SUBSTANCEPROTEIN, 
9197        /**
9198         * Todo.
9199         */
9200        SUBSTANCEREFERENCEINFORMATION, 
9201        /**
9202         * 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.
9203         */
9204        SUBSTANCESOURCEMATERIAL, 
9205        /**
9206         * Record of delivery of what is supplied.
9207         */
9208        SUPPLYDELIVERY, 
9209        /**
9210         * A record of a request for a medication, substance or device used in the healthcare setting.
9211         */
9212        SUPPLYREQUEST, 
9213        /**
9214         * A task to be performed.
9215         */
9216        TASK, 
9217        /**
9218         * A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
9219         */
9220        TERMINOLOGYCAPABILITIES, 
9221        /**
9222         * A summary of information based on the results of executing a TestScript.
9223         */
9224        TESTREPORT, 
9225        /**
9226         * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
9227         */
9228        TESTSCRIPT, 
9229        /**
9230         * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic.
9231         */
9232        TOPIC, 
9233        /**
9234         * 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).
9235         */
9236        VALUESET, 
9237        /**
9238         * Describes validation requirements, source(s), status and dates for one or more elements.
9239         */
9240        VERIFICATIONRESULT, 
9241        /**
9242         * An authorization for the provision of glasses and/or contact lenses to a patient.
9243         */
9244        VISIONPRESCRIPTION, 
9245        /**
9246         * added to help the parsers
9247         */
9248        NULL;
9249        public static ResourceTypeEnum fromCode(String codeString) throws FHIRException {
9250            if (codeString == null || "".equals(codeString))
9251                return null;
9252        if ("Account".equals(codeString))
9253          return ACCOUNT;
9254        if ("ActivityDefinition".equals(codeString))
9255          return ACTIVITYDEFINITION;
9256        if ("AdministrableProductDefinition".equals(codeString))
9257          return ADMINISTRABLEPRODUCTDEFINITION;
9258        if ("AdverseEvent".equals(codeString))
9259          return ADVERSEEVENT;
9260        if ("AllergyIntolerance".equals(codeString))
9261          return ALLERGYINTOLERANCE;
9262        if ("Appointment".equals(codeString))
9263          return APPOINTMENT;
9264        if ("AppointmentResponse".equals(codeString))
9265          return APPOINTMENTRESPONSE;
9266        if ("AuditEvent".equals(codeString))
9267          return AUDITEVENT;
9268        if ("Basic".equals(codeString))
9269          return BASIC;
9270        if ("Binary".equals(codeString))
9271          return BINARY;
9272        if ("BiologicallyDerivedProduct".equals(codeString))
9273          return BIOLOGICALLYDERIVEDPRODUCT;
9274        if ("BodyStructure".equals(codeString))
9275          return BODYSTRUCTURE;
9276        if ("Bundle".equals(codeString))
9277          return BUNDLE;
9278        if ("CapabilityStatement".equals(codeString))
9279          return CAPABILITYSTATEMENT;
9280        if ("CapabilityStatement2".equals(codeString))
9281          return CAPABILITYSTATEMENT2;
9282        if ("CarePlan".equals(codeString))
9283          return CAREPLAN;
9284        if ("CareTeam".equals(codeString))
9285          return CARETEAM;
9286        if ("CatalogEntry".equals(codeString))
9287          return CATALOGENTRY;
9288        if ("ChargeItem".equals(codeString))
9289          return CHARGEITEM;
9290        if ("ChargeItemDefinition".equals(codeString))
9291          return CHARGEITEMDEFINITION;
9292        if ("Claim".equals(codeString))
9293          return CLAIM;
9294        if ("ClaimResponse".equals(codeString))
9295          return CLAIMRESPONSE;
9296        if ("ClinicalImpression".equals(codeString))
9297          return CLINICALIMPRESSION;
9298        if ("ClinicalUseIssue".equals(codeString))
9299          return CLINICALUSEISSUE;
9300        if ("CodeSystem".equals(codeString))
9301          return CODESYSTEM;
9302        if ("Communication".equals(codeString))
9303          return COMMUNICATION;
9304        if ("CommunicationRequest".equals(codeString))
9305          return COMMUNICATIONREQUEST;
9306        if ("CompartmentDefinition".equals(codeString))
9307          return COMPARTMENTDEFINITION;
9308        if ("Composition".equals(codeString))
9309          return COMPOSITION;
9310        if ("ConceptMap".equals(codeString))
9311          return CONCEPTMAP;
9312        if ("Condition".equals(codeString))
9313          return CONDITION;
9314        if ("ConditionDefinition".equals(codeString))
9315          return CONDITIONDEFINITION;
9316        if ("Consent".equals(codeString))
9317          return CONSENT;
9318        if ("Contract".equals(codeString))
9319          return CONTRACT;
9320        if ("Coverage".equals(codeString))
9321          return COVERAGE;
9322        if ("CoverageEligibilityRequest".equals(codeString))
9323          return COVERAGEELIGIBILITYREQUEST;
9324        if ("CoverageEligibilityResponse".equals(codeString))
9325          return COVERAGEELIGIBILITYRESPONSE;
9326        if ("DetectedIssue".equals(codeString))
9327          return DETECTEDISSUE;
9328        if ("Device".equals(codeString))
9329          return DEVICE;
9330        if ("DeviceDefinition".equals(codeString))
9331          return DEVICEDEFINITION;
9332        if ("DeviceMetric".equals(codeString))
9333          return DEVICEMETRIC;
9334        if ("DeviceRequest".equals(codeString))
9335          return DEVICEREQUEST;
9336        if ("DeviceUseStatement".equals(codeString))
9337          return DEVICEUSESTATEMENT;
9338        if ("DiagnosticReport".equals(codeString))
9339          return DIAGNOSTICREPORT;
9340        if ("DocumentManifest".equals(codeString))
9341          return DOCUMENTMANIFEST;
9342        if ("DocumentReference".equals(codeString))
9343          return DOCUMENTREFERENCE;
9344        if ("DomainResource".equals(codeString))
9345          return DOMAINRESOURCE;
9346        if ("Encounter".equals(codeString))
9347          return ENCOUNTER;
9348        if ("Endpoint".equals(codeString))
9349          return ENDPOINT;
9350        if ("EnrollmentRequest".equals(codeString))
9351          return ENROLLMENTREQUEST;
9352        if ("EnrollmentResponse".equals(codeString))
9353          return ENROLLMENTRESPONSE;
9354        if ("EpisodeOfCare".equals(codeString))
9355          return EPISODEOFCARE;
9356        if ("EventDefinition".equals(codeString))
9357          return EVENTDEFINITION;
9358        if ("Evidence".equals(codeString))
9359          return EVIDENCE;
9360        if ("EvidenceVariable".equals(codeString))
9361          return EVIDENCEVARIABLE;
9362        if ("ExampleScenario".equals(codeString))
9363          return EXAMPLESCENARIO;
9364        if ("ExplanationOfBenefit".equals(codeString))
9365          return EXPLANATIONOFBENEFIT;
9366        if ("FamilyMemberHistory".equals(codeString))
9367          return FAMILYMEMBERHISTORY;
9368        if ("Flag".equals(codeString))
9369          return FLAG;
9370        if ("Goal".equals(codeString))
9371          return GOAL;
9372        if ("GraphDefinition".equals(codeString))
9373          return GRAPHDEFINITION;
9374        if ("Group".equals(codeString))
9375          return GROUP;
9376        if ("GuidanceResponse".equals(codeString))
9377          return GUIDANCERESPONSE;
9378        if ("HealthcareService".equals(codeString))
9379          return HEALTHCARESERVICE;
9380        if ("ImagingStudy".equals(codeString))
9381          return IMAGINGSTUDY;
9382        if ("Immunization".equals(codeString))
9383          return IMMUNIZATION;
9384        if ("ImmunizationEvaluation".equals(codeString))
9385          return IMMUNIZATIONEVALUATION;
9386        if ("ImmunizationRecommendation".equals(codeString))
9387          return IMMUNIZATIONRECOMMENDATION;
9388        if ("ImplementationGuide".equals(codeString))
9389          return IMPLEMENTATIONGUIDE;
9390        if ("Ingredient".equals(codeString))
9391          return INGREDIENT;
9392        if ("InsurancePlan".equals(codeString))
9393          return INSURANCEPLAN;
9394        if ("Invoice".equals(codeString))
9395          return INVOICE;
9396        if ("Library".equals(codeString))
9397          return LIBRARY;
9398        if ("Linkage".equals(codeString))
9399          return LINKAGE;
9400        if ("List".equals(codeString))
9401          return LIST;
9402        if ("Location".equals(codeString))
9403          return LOCATION;
9404        if ("ManufacturedItemDefinition".equals(codeString))
9405          return MANUFACTUREDITEMDEFINITION;
9406        if ("Measure".equals(codeString))
9407          return MEASURE;
9408        if ("MeasureReport".equals(codeString))
9409          return MEASUREREPORT;
9410        if ("Medication".equals(codeString))
9411          return MEDICATION;
9412        if ("MedicationAdministration".equals(codeString))
9413          return MEDICATIONADMINISTRATION;
9414        if ("MedicationDispense".equals(codeString))
9415          return MEDICATIONDISPENSE;
9416        if ("MedicationKnowledge".equals(codeString))
9417          return MEDICATIONKNOWLEDGE;
9418        if ("MedicationRequest".equals(codeString))
9419          return MEDICATIONREQUEST;
9420        if ("MedicationUsage".equals(codeString))
9421          return MEDICATIONUSAGE;
9422        if ("MedicinalProductDefinition".equals(codeString))
9423          return MEDICINALPRODUCTDEFINITION;
9424        if ("MessageDefinition".equals(codeString))
9425          return MESSAGEDEFINITION;
9426        if ("MessageHeader".equals(codeString))
9427          return MESSAGEHEADER;
9428        if ("MolecularSequence".equals(codeString))
9429          return MOLECULARSEQUENCE;
9430        if ("NamingSystem".equals(codeString))
9431          return NAMINGSYSTEM;
9432        if ("NutritionIntake".equals(codeString))
9433          return NUTRITIONINTAKE;
9434        if ("NutritionOrder".equals(codeString))
9435          return NUTRITIONORDER;
9436        if ("Observation".equals(codeString))
9437          return OBSERVATION;
9438        if ("ObservationDefinition".equals(codeString))
9439          return OBSERVATIONDEFINITION;
9440        if ("OperationDefinition".equals(codeString))
9441          return OPERATIONDEFINITION;
9442        if ("OperationOutcome".equals(codeString))
9443          return OPERATIONOUTCOME;
9444        if ("Organization".equals(codeString))
9445          return ORGANIZATION;
9446        if ("OrganizationAffiliation".equals(codeString))
9447          return ORGANIZATIONAFFILIATION;
9448        if ("PackagedProductDefinition".equals(codeString))
9449          return PACKAGEDPRODUCTDEFINITION;
9450        if ("Parameters".equals(codeString))
9451          return PARAMETERS;
9452        if ("Patient".equals(codeString))
9453          return PATIENT;
9454        if ("PaymentNotice".equals(codeString))
9455          return PAYMENTNOTICE;
9456        if ("PaymentReconciliation".equals(codeString))
9457          return PAYMENTRECONCILIATION;
9458        if ("Person".equals(codeString))
9459          return PERSON;
9460        if ("PlanDefinition".equals(codeString))
9461          return PLANDEFINITION;
9462        if ("Practitioner".equals(codeString))
9463          return PRACTITIONER;
9464        if ("PractitionerRole".equals(codeString))
9465          return PRACTITIONERROLE;
9466        if ("Procedure".equals(codeString))
9467          return PROCEDURE;
9468        if ("Provenance".equals(codeString))
9469          return PROVENANCE;
9470        if ("Questionnaire".equals(codeString))
9471          return QUESTIONNAIRE;
9472        if ("QuestionnaireResponse".equals(codeString))
9473          return QUESTIONNAIRERESPONSE;
9474        if ("RegulatedAuthorization".equals(codeString))
9475          return REGULATEDAUTHORIZATION;
9476        if ("RelatedPerson".equals(codeString))
9477          return RELATEDPERSON;
9478        if ("RequestGroup".equals(codeString))
9479          return REQUESTGROUP;
9480        if ("ResearchStudy".equals(codeString))
9481          return RESEARCHSTUDY;
9482        if ("ResearchSubject".equals(codeString))
9483          return RESEARCHSUBJECT;
9484        if ("Resource".equals(codeString))
9485          return RESOURCE;
9486        if ("RiskAssessment".equals(codeString))
9487          return RISKASSESSMENT;
9488        if ("Schedule".equals(codeString))
9489          return SCHEDULE;
9490        if ("SearchParameter".equals(codeString))
9491          return SEARCHPARAMETER;
9492        if ("ServiceRequest".equals(codeString))
9493          return SERVICEREQUEST;
9494        if ("Slot".equals(codeString))
9495          return SLOT;
9496        if ("Specimen".equals(codeString))
9497          return SPECIMEN;
9498        if ("SpecimenDefinition".equals(codeString))
9499          return SPECIMENDEFINITION;
9500        if ("StructureDefinition".equals(codeString))
9501          return STRUCTUREDEFINITION;
9502        if ("StructureMap".equals(codeString))
9503          return STRUCTUREMAP;
9504        if ("Subscription".equals(codeString))
9505          return SUBSCRIPTION;
9506        if ("Substance".equals(codeString))
9507          return SUBSTANCE;
9508        if ("SubstanceDefinition".equals(codeString))
9509          return SUBSTANCEDEFINITION;
9510        if ("SubstanceNucleicAcid".equals(codeString))
9511          return SUBSTANCENUCLEICACID;
9512        if ("SubstancePolymer".equals(codeString))
9513          return SUBSTANCEPOLYMER;
9514        if ("SubstanceProtein".equals(codeString))
9515          return SUBSTANCEPROTEIN;
9516        if ("SubstanceReferenceInformation".equals(codeString))
9517          return SUBSTANCEREFERENCEINFORMATION;
9518        if ("SubstanceSourceMaterial".equals(codeString))
9519          return SUBSTANCESOURCEMATERIAL;
9520        if ("SupplyDelivery".equals(codeString))
9521          return SUPPLYDELIVERY;
9522        if ("SupplyRequest".equals(codeString))
9523          return SUPPLYREQUEST;
9524        if ("Task".equals(codeString))
9525          return TASK;
9526        if ("TerminologyCapabilities".equals(codeString))
9527          return TERMINOLOGYCAPABILITIES;
9528        if ("TestReport".equals(codeString))
9529          return TESTREPORT;
9530        if ("TestScript".equals(codeString))
9531          return TESTSCRIPT;
9532        if ("Topic".equals(codeString))
9533          return TOPIC;
9534        if ("ValueSet".equals(codeString))
9535          return VALUESET;
9536        if ("VerificationResult".equals(codeString))
9537          return VERIFICATIONRESULT;
9538        if ("VisionPrescription".equals(codeString))
9539          return VISIONPRESCRIPTION;
9540        throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'");
9541        }
9542        public String toCode() {
9543          switch (this) {
9544            case ACCOUNT: return "Account";
9545            case ACTIVITYDEFINITION: return "ActivityDefinition";
9546            case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition";
9547            case ADVERSEEVENT: return "AdverseEvent";
9548            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
9549            case APPOINTMENT: return "Appointment";
9550            case APPOINTMENTRESPONSE: return "AppointmentResponse";
9551            case AUDITEVENT: return "AuditEvent";
9552            case BASIC: return "Basic";
9553            case BINARY: return "Binary";
9554            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
9555            case BODYSTRUCTURE: return "BodyStructure";
9556            case BUNDLE: return "Bundle";
9557            case CAPABILITYSTATEMENT: return "CapabilityStatement";
9558            case CAPABILITYSTATEMENT2: return "CapabilityStatement2";
9559            case CAREPLAN: return "CarePlan";
9560            case CARETEAM: return "CareTeam";
9561            case CATALOGENTRY: return "CatalogEntry";
9562            case CHARGEITEM: return "ChargeItem";
9563            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
9564            case CLAIM: return "Claim";
9565            case CLAIMRESPONSE: return "ClaimResponse";
9566            case CLINICALIMPRESSION: return "ClinicalImpression";
9567            case CLINICALUSEISSUE: return "ClinicalUseIssue";
9568            case CODESYSTEM: return "CodeSystem";
9569            case COMMUNICATION: return "Communication";
9570            case COMMUNICATIONREQUEST: return "CommunicationRequest";
9571            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
9572            case COMPOSITION: return "Composition";
9573            case CONCEPTMAP: return "ConceptMap";
9574            case CONDITION: return "Condition";
9575            case CONDITIONDEFINITION: return "ConditionDefinition";
9576            case CONSENT: return "Consent";
9577            case CONTRACT: return "Contract";
9578            case COVERAGE: return "Coverage";
9579            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
9580            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
9581            case DETECTEDISSUE: return "DetectedIssue";
9582            case DEVICE: return "Device";
9583            case DEVICEDEFINITION: return "DeviceDefinition";
9584            case DEVICEMETRIC: return "DeviceMetric";
9585            case DEVICEREQUEST: return "DeviceRequest";
9586            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
9587            case DIAGNOSTICREPORT: return "DiagnosticReport";
9588            case DOCUMENTMANIFEST: return "DocumentManifest";
9589            case DOCUMENTREFERENCE: return "DocumentReference";
9590            case DOMAINRESOURCE: return "DomainResource";
9591            case ENCOUNTER: return "Encounter";
9592            case ENDPOINT: return "Endpoint";
9593            case ENROLLMENTREQUEST: return "EnrollmentRequest";
9594            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
9595            case EPISODEOFCARE: return "EpisodeOfCare";
9596            case EVENTDEFINITION: return "EventDefinition";
9597            case EVIDENCE: return "Evidence";
9598            case EVIDENCEVARIABLE: return "EvidenceVariable";
9599            case EXAMPLESCENARIO: return "ExampleScenario";
9600            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
9601            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
9602            case FLAG: return "Flag";
9603            case GOAL: return "Goal";
9604            case GRAPHDEFINITION: return "GraphDefinition";
9605            case GROUP: return "Group";
9606            case GUIDANCERESPONSE: return "GuidanceResponse";
9607            case HEALTHCARESERVICE: return "HealthcareService";
9608            case IMAGINGSTUDY: return "ImagingStudy";
9609            case IMMUNIZATION: return "Immunization";
9610            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
9611            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
9612            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
9613            case INGREDIENT: return "Ingredient";
9614            case INSURANCEPLAN: return "InsurancePlan";
9615            case INVOICE: return "Invoice";
9616            case LIBRARY: return "Library";
9617            case LINKAGE: return "Linkage";
9618            case LIST: return "List";
9619            case LOCATION: return "Location";
9620            case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition";
9621            case MEASURE: return "Measure";
9622            case MEASUREREPORT: return "MeasureReport";
9623            case MEDICATION: return "Medication";
9624            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
9625            case MEDICATIONDISPENSE: return "MedicationDispense";
9626            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
9627            case MEDICATIONREQUEST: return "MedicationRequest";
9628            case MEDICATIONUSAGE: return "MedicationUsage";
9629            case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition";
9630            case MESSAGEDEFINITION: return "MessageDefinition";
9631            case MESSAGEHEADER: return "MessageHeader";
9632            case MOLECULARSEQUENCE: return "MolecularSequence";
9633            case NAMINGSYSTEM: return "NamingSystem";
9634            case NUTRITIONINTAKE: return "NutritionIntake";
9635            case NUTRITIONORDER: return "NutritionOrder";
9636            case OBSERVATION: return "Observation";
9637            case OBSERVATIONDEFINITION: return "ObservationDefinition";
9638            case OPERATIONDEFINITION: return "OperationDefinition";
9639            case OPERATIONOUTCOME: return "OperationOutcome";
9640            case ORGANIZATION: return "Organization";
9641            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
9642            case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition";
9643            case PARAMETERS: return "Parameters";
9644            case PATIENT: return "Patient";
9645            case PAYMENTNOTICE: return "PaymentNotice";
9646            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
9647            case PERSON: return "Person";
9648            case PLANDEFINITION: return "PlanDefinition";
9649            case PRACTITIONER: return "Practitioner";
9650            case PRACTITIONERROLE: return "PractitionerRole";
9651            case PROCEDURE: return "Procedure";
9652            case PROVENANCE: return "Provenance";
9653            case QUESTIONNAIRE: return "Questionnaire";
9654            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
9655            case REGULATEDAUTHORIZATION: return "RegulatedAuthorization";
9656            case RELATEDPERSON: return "RelatedPerson";
9657            case REQUESTGROUP: return "RequestGroup";
9658            case RESEARCHSTUDY: return "ResearchStudy";
9659            case RESEARCHSUBJECT: return "ResearchSubject";
9660            case RESOURCE: return "Resource";
9661            case RISKASSESSMENT: return "RiskAssessment";
9662            case SCHEDULE: return "Schedule";
9663            case SEARCHPARAMETER: return "SearchParameter";
9664            case SERVICEREQUEST: return "ServiceRequest";
9665            case SLOT: return "Slot";
9666            case SPECIMEN: return "Specimen";
9667            case SPECIMENDEFINITION: return "SpecimenDefinition";
9668            case STRUCTUREDEFINITION: return "StructureDefinition";
9669            case STRUCTUREMAP: return "StructureMap";
9670            case SUBSCRIPTION: return "Subscription";
9671            case SUBSTANCE: return "Substance";
9672            case SUBSTANCEDEFINITION: return "SubstanceDefinition";
9673            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
9674            case SUBSTANCEPOLYMER: return "SubstancePolymer";
9675            case SUBSTANCEPROTEIN: return "SubstanceProtein";
9676            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
9677            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
9678            case SUPPLYDELIVERY: return "SupplyDelivery";
9679            case SUPPLYREQUEST: return "SupplyRequest";
9680            case TASK: return "Task";
9681            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
9682            case TESTREPORT: return "TestReport";
9683            case TESTSCRIPT: return "TestScript";
9684            case TOPIC: return "Topic";
9685            case VALUESET: return "ValueSet";
9686            case VERIFICATIONRESULT: return "VerificationResult";
9687            case VISIONPRESCRIPTION: return "VisionPrescription";
9688            default: return "?";
9689          }
9690        }
9691        public String getSystem() {
9692          switch (this) {
9693            case ACCOUNT: return "http://hl7.org/fhir/resource-types";
9694            case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types";
9695            case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
9696            case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types";
9697            case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types";
9698            case APPOINTMENT: return "http://hl7.org/fhir/resource-types";
9699            case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
9700            case AUDITEVENT: return "http://hl7.org/fhir/resource-types";
9701            case BASIC: return "http://hl7.org/fhir/resource-types";
9702            case BINARY: return "http://hl7.org/fhir/resource-types";
9703            case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types";
9704            case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types";
9705            case BUNDLE: return "http://hl7.org/fhir/resource-types";
9706            case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types";
9707            case CAPABILITYSTATEMENT2: return "http://hl7.org/fhir/resource-types";
9708            case CAREPLAN: return "http://hl7.org/fhir/resource-types";
9709            case CARETEAM: return "http://hl7.org/fhir/resource-types";
9710            case CATALOGENTRY: return "http://hl7.org/fhir/resource-types";
9711            case CHARGEITEM: return "http://hl7.org/fhir/resource-types";
9712            case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
9713            case CLAIM: return "http://hl7.org/fhir/resource-types";
9714            case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types";
9715            case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types";
9716            case CLINICALUSEISSUE: return "http://hl7.org/fhir/resource-types";
9717            case CODESYSTEM: return "http://hl7.org/fhir/resource-types";
9718            case COMMUNICATION: return "http://hl7.org/fhir/resource-types";
9719            case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
9720            case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types";
9721            case COMPOSITION: return "http://hl7.org/fhir/resource-types";
9722            case CONCEPTMAP: return "http://hl7.org/fhir/resource-types";
9723            case CONDITION: return "http://hl7.org/fhir/resource-types";
9724            case CONDITIONDEFINITION: return "http://hl7.org/fhir/resource-types";
9725            case CONSENT: return "http://hl7.org/fhir/resource-types";
9726            case CONTRACT: return "http://hl7.org/fhir/resource-types";
9727            case COVERAGE: return "http://hl7.org/fhir/resource-types";
9728            case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types";
9729            case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types";
9730            case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types";
9731            case DEVICE: return "http://hl7.org/fhir/resource-types";
9732            case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types";
9733            case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types";
9734            case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types";
9735            case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types";
9736            case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types";
9737            case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types";
9738            case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types";
9739            case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types";
9740            case ENCOUNTER: return "http://hl7.org/fhir/resource-types";
9741            case ENDPOINT: return "http://hl7.org/fhir/resource-types";
9742            case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types";
9743            case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types";
9744            case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types";
9745            case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types";
9746            case EVIDENCE: return "http://hl7.org/fhir/resource-types";
9747            case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types";
9748            case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types";
9749            case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types";
9750            case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types";
9751            case FLAG: return "http://hl7.org/fhir/resource-types";
9752            case GOAL: return "http://hl7.org/fhir/resource-types";
9753            case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types";
9754            case GROUP: return "http://hl7.org/fhir/resource-types";
9755            case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types";
9756            case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types";
9757            case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types";
9758            case IMMUNIZATION: return "http://hl7.org/fhir/resource-types";
9759            case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types";
9760            case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types";
9761            case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types";
9762            case INGREDIENT: return "http://hl7.org/fhir/resource-types";
9763            case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types";
9764            case INVOICE: return "http://hl7.org/fhir/resource-types";
9765            case LIBRARY: return "http://hl7.org/fhir/resource-types";
9766            case LINKAGE: return "http://hl7.org/fhir/resource-types";
9767            case LIST: return "http://hl7.org/fhir/resource-types";
9768            case LOCATION: return "http://hl7.org/fhir/resource-types";
9769            case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/resource-types";
9770            case MEASURE: return "http://hl7.org/fhir/resource-types";
9771            case MEASUREREPORT: return "http://hl7.org/fhir/resource-types";
9772            case MEDICATION: return "http://hl7.org/fhir/resource-types";
9773            case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types";
9774            case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types";
9775            case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types";
9776            case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types";
9777            case MEDICATIONUSAGE: return "http://hl7.org/fhir/resource-types";
9778            case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
9779            case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types";
9780            case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types";
9781            case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types";
9782            case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types";
9783            case NUTRITIONINTAKE: return "http://hl7.org/fhir/resource-types";
9784            case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types";
9785            case OBSERVATION: return "http://hl7.org/fhir/resource-types";
9786            case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
9787            case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types";
9788            case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types";
9789            case ORGANIZATION: return "http://hl7.org/fhir/resource-types";
9790            case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types";
9791            case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types";
9792            case PARAMETERS: return "http://hl7.org/fhir/resource-types";
9793            case PATIENT: return "http://hl7.org/fhir/resource-types";
9794            case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types";
9795            case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types";
9796            case PERSON: return "http://hl7.org/fhir/resource-types";
9797            case PLANDEFINITION: return "http://hl7.org/fhir/resource-types";
9798            case PRACTITIONER: return "http://hl7.org/fhir/resource-types";
9799            case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types";
9800            case PROCEDURE: return "http://hl7.org/fhir/resource-types";
9801            case PROVENANCE: return "http://hl7.org/fhir/resource-types";
9802            case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types";
9803            case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types";
9804            case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/resource-types";
9805            case RELATEDPERSON: return "http://hl7.org/fhir/resource-types";
9806            case REQUESTGROUP: return "http://hl7.org/fhir/resource-types";
9807            case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types";
9808            case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types";
9809            case RESOURCE: return "http://hl7.org/fhir/resource-types";
9810            case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types";
9811            case SCHEDULE: return "http://hl7.org/fhir/resource-types";
9812            case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types";
9813            case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types";
9814            case SLOT: return "http://hl7.org/fhir/resource-types";
9815            case SPECIMEN: return "http://hl7.org/fhir/resource-types";
9816            case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types";
9817            case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types";
9818            case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types";
9819            case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types";
9820            case SUBSTANCE: return "http://hl7.org/fhir/resource-types";
9821            case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/resource-types";
9822            case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types";
9823            case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types";
9824            case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types";
9825            case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types";
9826            case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types";
9827            case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types";
9828            case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types";
9829            case TASK: return "http://hl7.org/fhir/resource-types";
9830            case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types";
9831            case TESTREPORT: return "http://hl7.org/fhir/resource-types";
9832            case TESTSCRIPT: return "http://hl7.org/fhir/resource-types";
9833            case TOPIC: return "http://hl7.org/fhir/resource-types";
9834            case VALUESET: return "http://hl7.org/fhir/resource-types";
9835            case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types";
9836            case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types";
9837            default: return "?";
9838          }
9839        }
9840        public String getDefinition() {
9841          switch (this) {
9842            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.";
9843            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.";
9844            case ADMINISTRABLEPRODUCTDEFINITION: return "A pharmaceutical product described in terms of its composition and dose form.";
9845            case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject.  The unintended effects may require additional monitoring, treatment or hospitalization or may result in death.  The AdverseEvent resource also extends to potential or avoided events that could have had such effects.";
9846            case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.";
9847            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).";
9848            case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.";
9849            case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis.";
9850            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.";
9851            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.";
9852            case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity.";
9853            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.";
9854            case BUNDLE: return "A container for a collection of resources.";
9855            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.";
9856            case CAPABILITYSTATEMENT2: 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.";
9857            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.";
9858            case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care.";
9859            case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog.";
9860            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.";
9861            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.";
9862            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.";
9863            case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource.";
9864            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.";
9865            case CLINICALUSEISSUE: return "A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure.";
9866            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.";
9867            case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition.";
9868            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.";
9869            case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server.";
9870            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.).";
9871            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.";
9872            case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.";
9873            case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it.";
9874            case CONSENT: return "A record of a healthcare consumer’s  choices  or choices made on their behalf by a third party, 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.";
9875            case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.";
9876            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.";
9877            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.";
9878            case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.";
9879            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.";
9880            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.";
9881            case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device.";
9882            case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device.";
9883            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.";
9884            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.";
9885            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.";
9886            case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection.";
9887            case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this \"document\" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare.  The DocumentReference resource provides metadata about the document so that the document can be discovered and managed.  The actual content may be inline base64 encoded data or provided by direct reference.";
9888            case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources.";
9889            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.";
9890            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.";
9891            case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage.";
9892            case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.";
9893            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.";
9894            case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur.";
9895            case EVIDENCE: return "This represents statistics, certainty, both the intended and actual population, and evidence variables.";
9896            case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about.";
9897            case EXAMPLESCENARIO: return "Example of workflow instance.";
9898            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.";
9899            case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient.";
9900            case FLAG: return "Prospective warnings of potential issues when providing care to the patient.";
9901            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.";
9902            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.";
9903            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.";
9904            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.";
9905            case HEALTHCARESERVICE: return "The details of a healthcare service available at a location.";
9906            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.";
9907            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.";
9908            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.";
9909            case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.";
9910            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.";
9911            case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product.";
9912            case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization.";
9913            case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.";
9914            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.";
9915            case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\".";
9916            case LIST: return "A list is a curated collection of resources.";
9917            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.";
9918            case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product.";
9919            case MEASURE: return "The Measure resource provides the definition of a quality measure.";
9920            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.";
9921            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.";
9922            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.";
9923            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.";
9924            case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge.";
9925            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.";
9926            case MEDICATIONUSAGE: return "A record of a medication that is being consumed by a patient.   A MedicationUsage 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 medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medicationusage 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 Usage 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.";
9927            case MEDICINALPRODUCTDEFINITION: return "Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use).";
9928            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.";
9929            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.";
9930            case MOLECULARSEQUENCE: return "Raw data describing a biological sequence.";
9931            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.";
9932            case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient.   A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past.  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 or through an app that tracks food or fluids consumed.   The consumption information may come from sources such as the patient's memory, from a nutrition label,  or from a clinician documenting observed intake.";
9933            case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.";
9934            case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject.";
9935            case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.";
9936            case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).";
9937            case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action.";
9938            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.";
9939            case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship.";
9940            case PACKAGEDPRODUCTDEFINITION: return "A medicinal product in a container or package.";
9941            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.";
9942            case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services.";
9943            case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references.";
9944            case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid.";
9945            case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context.";
9946            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.";
9947            case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare.";
9948            case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.";
9949            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.";
9950            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.";
9951            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.";
9952            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.";
9953            case REGULATEDAUTHORIZATION: return "The regulatory authorization of a medicinal product.";
9954            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.";
9955            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\".";
9956            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.";
9957            case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study.";
9958            case RESOURCE: return "This is the base resource type for everything.";
9959            case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.";
9960            case SCHEDULE: return "A container for slots of time that may be available for booking appointments.";
9961            case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource.";
9962            case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.";
9963            case SLOT: return "A slot of time on a schedule that may be available for booking appointments.";
9964            case SPECIMEN: return "A sample to be used for analysis.";
9965            case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements.";
9966            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.";
9967            case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data.";
9968            case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a Topic.";
9969            case SUBSTANCE: return "A homogeneous material with a definite composition.";
9970            case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing.";
9971            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.";
9972            case SUBSTANCEPOLYMER: return "Todo.";
9973            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.";
9974            case SUBSTANCEREFERENCEINFORMATION: return "Todo.";
9975            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.";
9976            case SUPPLYDELIVERY: return "Record of delivery of what is supplied.";
9977            case SUPPLYREQUEST: return "A record of a request for a medication, substance or device used in the healthcare setting.";
9978            case TASK: return "A task to be performed.";
9979            case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.";
9980            case TESTREPORT: return "A summary of information based on the results of executing a TestScript.";
9981            case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.";
9982            case TOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic.";
9983            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).";
9984            case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements.";
9985            case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient.";
9986            default: return "?";
9987          }
9988        }
9989        public String getDisplay() {
9990          switch (this) {
9991            case ACCOUNT: return "Account";
9992            case ACTIVITYDEFINITION: return "ActivityDefinition";
9993            case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition";
9994            case ADVERSEEVENT: return "AdverseEvent";
9995            case ALLERGYINTOLERANCE: return "AllergyIntolerance";
9996            case APPOINTMENT: return "Appointment";
9997            case APPOINTMENTRESPONSE: return "AppointmentResponse";
9998            case AUDITEVENT: return "AuditEvent";
9999            case BASIC: return "Basic";
10000            case BINARY: return "Binary";
10001            case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct";
10002            case BODYSTRUCTURE: return "BodyStructure";
10003            case BUNDLE: return "Bundle";
10004            case CAPABILITYSTATEMENT: return "CapabilityStatement";
10005            case CAPABILITYSTATEMENT2: return "CapabilityStatement2";
10006            case CAREPLAN: return "CarePlan";
10007            case CARETEAM: return "CareTeam";
10008            case CATALOGENTRY: return "CatalogEntry";
10009            case CHARGEITEM: return "ChargeItem";
10010            case CHARGEITEMDEFINITION: return "ChargeItemDefinition";
10011            case CLAIM: return "Claim";
10012            case CLAIMRESPONSE: return "ClaimResponse";
10013            case CLINICALIMPRESSION: return "ClinicalImpression";
10014            case CLINICALUSEISSUE: return "ClinicalUseIssue";
10015            case CODESYSTEM: return "CodeSystem";
10016            case COMMUNICATION: return "Communication";
10017            case COMMUNICATIONREQUEST: return "CommunicationRequest";
10018            case COMPARTMENTDEFINITION: return "CompartmentDefinition";
10019            case COMPOSITION: return "Composition";
10020            case CONCEPTMAP: return "ConceptMap";
10021            case CONDITION: return "Condition";
10022            case CONDITIONDEFINITION: return "ConditionDefinition";
10023            case CONSENT: return "Consent";
10024            case CONTRACT: return "Contract";
10025            case COVERAGE: return "Coverage";
10026            case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest";
10027            case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse";
10028            case DETECTEDISSUE: return "DetectedIssue";
10029            case DEVICE: return "Device";
10030            case DEVICEDEFINITION: return "DeviceDefinition";
10031            case DEVICEMETRIC: return "DeviceMetric";
10032            case DEVICEREQUEST: return "DeviceRequest";
10033            case DEVICEUSESTATEMENT: return "DeviceUseStatement";
10034            case DIAGNOSTICREPORT: return "DiagnosticReport";
10035            case DOCUMENTMANIFEST: return "DocumentManifest";
10036            case DOCUMENTREFERENCE: return "DocumentReference";
10037            case DOMAINRESOURCE: return "DomainResource";
10038            case ENCOUNTER: return "Encounter";
10039            case ENDPOINT: return "Endpoint";
10040            case ENROLLMENTREQUEST: return "EnrollmentRequest";
10041            case ENROLLMENTRESPONSE: return "EnrollmentResponse";
10042            case EPISODEOFCARE: return "EpisodeOfCare";
10043            case EVENTDEFINITION: return "EventDefinition";
10044            case EVIDENCE: return "Evidence";
10045            case EVIDENCEVARIABLE: return "EvidenceVariable";
10046            case EXAMPLESCENARIO: return "ExampleScenario";
10047            case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit";
10048            case FAMILYMEMBERHISTORY: return "FamilyMemberHistory";
10049            case FLAG: return "Flag";
10050            case GOAL: return "Goal";
10051            case GRAPHDEFINITION: return "GraphDefinition";
10052            case GROUP: return "Group";
10053            case GUIDANCERESPONSE: return "GuidanceResponse";
10054            case HEALTHCARESERVICE: return "HealthcareService";
10055            case IMAGINGSTUDY: return "ImagingStudy";
10056            case IMMUNIZATION: return "Immunization";
10057            case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation";
10058            case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation";
10059            case IMPLEMENTATIONGUIDE: return "ImplementationGuide";
10060            case INGREDIENT: return "Ingredient";
10061            case INSURANCEPLAN: return "InsurancePlan";
10062            case INVOICE: return "Invoice";
10063            case LIBRARY: return "Library";
10064            case LINKAGE: return "Linkage";
10065            case LIST: return "List";
10066            case LOCATION: return "Location";
10067            case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition";
10068            case MEASURE: return "Measure";
10069            case MEASUREREPORT: return "MeasureReport";
10070            case MEDICATION: return "Medication";
10071            case MEDICATIONADMINISTRATION: return "MedicationAdministration";
10072            case MEDICATIONDISPENSE: return "MedicationDispense";
10073            case MEDICATIONKNOWLEDGE: return "MedicationKnowledge";
10074            case MEDICATIONREQUEST: return "MedicationRequest";
10075            case MEDICATIONUSAGE: return "MedicationUsage";
10076            case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition";
10077            case MESSAGEDEFINITION: return "MessageDefinition";
10078            case MESSAGEHEADER: return "MessageHeader";
10079            case MOLECULARSEQUENCE: return "MolecularSequence";
10080            case NAMINGSYSTEM: return "NamingSystem";
10081            case NUTRITIONINTAKE: return "NutritionIntake";
10082            case NUTRITIONORDER: return "NutritionOrder";
10083            case OBSERVATION: return "Observation";
10084            case OBSERVATIONDEFINITION: return "ObservationDefinition";
10085            case OPERATIONDEFINITION: return "OperationDefinition";
10086            case OPERATIONOUTCOME: return "OperationOutcome";
10087            case ORGANIZATION: return "Organization";
10088            case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation";
10089            case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition";
10090            case PARAMETERS: return "Parameters";
10091            case PATIENT: return "Patient";
10092            case PAYMENTNOTICE: return "PaymentNotice";
10093            case PAYMENTRECONCILIATION: return "PaymentReconciliation";
10094            case PERSON: return "Person";
10095            case PLANDEFINITION: return "PlanDefinition";
10096            case PRACTITIONER: return "Practitioner";
10097            case PRACTITIONERROLE: return "PractitionerRole";
10098            case PROCEDURE: return "Procedure";
10099            case PROVENANCE: return "Provenance";
10100            case QUESTIONNAIRE: return "Questionnaire";
10101            case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse";
10102            case REGULATEDAUTHORIZATION: return "RegulatedAuthorization";
10103            case RELATEDPERSON: return "RelatedPerson";
10104            case REQUESTGROUP: return "RequestGroup";
10105            case RESEARCHSTUDY: return "ResearchStudy";
10106            case RESEARCHSUBJECT: return "ResearchSubject";
10107            case RESOURCE: return "Resource";
10108            case RISKASSESSMENT: return "RiskAssessment";
10109            case SCHEDULE: return "Schedule";
10110            case SEARCHPARAMETER: return "SearchParameter";
10111            case SERVICEREQUEST: return "ServiceRequest";
10112            case SLOT: return "Slot";
10113            case SPECIMEN: return "Specimen";
10114            case SPECIMENDEFINITION: return "SpecimenDefinition";
10115            case STRUCTUREDEFINITION: return "StructureDefinition";
10116            case STRUCTUREMAP: return "StructureMap";
10117            case SUBSCRIPTION: return "Subscription";
10118            case SUBSTANCE: return "Substance";
10119            case SUBSTANCEDEFINITION: return "SubstanceDefinition";
10120            case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid";
10121            case SUBSTANCEPOLYMER: return "SubstancePolymer";
10122            case SUBSTANCEPROTEIN: return "SubstanceProtein";
10123            case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation";
10124            case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial";
10125            case SUPPLYDELIVERY: return "SupplyDelivery";
10126            case SUPPLYREQUEST: return "SupplyRequest";
10127            case TASK: return "Task";
10128            case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities";
10129            case TESTREPORT: return "TestReport";
10130            case TESTSCRIPT: return "TestScript";
10131            case TOPIC: return "Topic";
10132            case VALUESET: return "ValueSet";
10133            case VERIFICATIONRESULT: return "VerificationResult";
10134            case VISIONPRESCRIPTION: return "VisionPrescription";
10135            default: return "?";
10136          }
10137        }
10138    }
10139
10140  public static class ResourceTypeEnumEnumFactory implements EnumFactory<ResourceTypeEnum> {
10141    public ResourceTypeEnum fromCode(String codeString) throws IllegalArgumentException {
10142      if (codeString == null || "".equals(codeString))
10143            if (codeString == null || "".equals(codeString))
10144                return null;
10145        if ("Account".equals(codeString))
10146          return ResourceTypeEnum.ACCOUNT;
10147        if ("ActivityDefinition".equals(codeString))
10148          return ResourceTypeEnum.ACTIVITYDEFINITION;
10149        if ("AdministrableProductDefinition".equals(codeString))
10150          return ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION;
10151        if ("AdverseEvent".equals(codeString))
10152          return ResourceTypeEnum.ADVERSEEVENT;
10153        if ("AllergyIntolerance".equals(codeString))
10154          return ResourceTypeEnum.ALLERGYINTOLERANCE;
10155        if ("Appointment".equals(codeString))
10156          return ResourceTypeEnum.APPOINTMENT;
10157        if ("AppointmentResponse".equals(codeString))
10158          return ResourceTypeEnum.APPOINTMENTRESPONSE;
10159        if ("AuditEvent".equals(codeString))
10160          return ResourceTypeEnum.AUDITEVENT;
10161        if ("Basic".equals(codeString))
10162          return ResourceTypeEnum.BASIC;
10163        if ("Binary".equals(codeString))
10164          return ResourceTypeEnum.BINARY;
10165        if ("BiologicallyDerivedProduct".equals(codeString))
10166          return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT;
10167        if ("BodyStructure".equals(codeString))
10168          return ResourceTypeEnum.BODYSTRUCTURE;
10169        if ("Bundle".equals(codeString))
10170          return ResourceTypeEnum.BUNDLE;
10171        if ("CapabilityStatement".equals(codeString))
10172          return ResourceTypeEnum.CAPABILITYSTATEMENT;
10173        if ("CapabilityStatement2".equals(codeString))
10174          return ResourceTypeEnum.CAPABILITYSTATEMENT2;
10175        if ("CarePlan".equals(codeString))
10176          return ResourceTypeEnum.CAREPLAN;
10177        if ("CareTeam".equals(codeString))
10178          return ResourceTypeEnum.CARETEAM;
10179        if ("CatalogEntry".equals(codeString))
10180          return ResourceTypeEnum.CATALOGENTRY;
10181        if ("ChargeItem".equals(codeString))
10182          return ResourceTypeEnum.CHARGEITEM;
10183        if ("ChargeItemDefinition".equals(codeString))
10184          return ResourceTypeEnum.CHARGEITEMDEFINITION;
10185        if ("Claim".equals(codeString))
10186          return ResourceTypeEnum.CLAIM;
10187        if ("ClaimResponse".equals(codeString))
10188          return ResourceTypeEnum.CLAIMRESPONSE;
10189        if ("ClinicalImpression".equals(codeString))
10190          return ResourceTypeEnum.CLINICALIMPRESSION;
10191        if ("ClinicalUseIssue".equals(codeString))
10192          return ResourceTypeEnum.CLINICALUSEISSUE;
10193        if ("CodeSystem".equals(codeString))
10194          return ResourceTypeEnum.CODESYSTEM;
10195        if ("Communication".equals(codeString))
10196          return ResourceTypeEnum.COMMUNICATION;
10197        if ("CommunicationRequest".equals(codeString))
10198          return ResourceTypeEnum.COMMUNICATIONREQUEST;
10199        if ("CompartmentDefinition".equals(codeString))
10200          return ResourceTypeEnum.COMPARTMENTDEFINITION;
10201        if ("Composition".equals(codeString))
10202          return ResourceTypeEnum.COMPOSITION;
10203        if ("ConceptMap".equals(codeString))
10204          return ResourceTypeEnum.CONCEPTMAP;
10205        if ("Condition".equals(codeString))
10206          return ResourceTypeEnum.CONDITION;
10207        if ("ConditionDefinition".equals(codeString))
10208          return ResourceTypeEnum.CONDITIONDEFINITION;
10209        if ("Consent".equals(codeString))
10210          return ResourceTypeEnum.CONSENT;
10211        if ("Contract".equals(codeString))
10212          return ResourceTypeEnum.CONTRACT;
10213        if ("Coverage".equals(codeString))
10214          return ResourceTypeEnum.COVERAGE;
10215        if ("CoverageEligibilityRequest".equals(codeString))
10216          return ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST;
10217        if ("CoverageEligibilityResponse".equals(codeString))
10218          return ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE;
10219        if ("DetectedIssue".equals(codeString))
10220          return ResourceTypeEnum.DETECTEDISSUE;
10221        if ("Device".equals(codeString))
10222          return ResourceTypeEnum.DEVICE;
10223        if ("DeviceDefinition".equals(codeString))
10224          return ResourceTypeEnum.DEVICEDEFINITION;
10225        if ("DeviceMetric".equals(codeString))
10226          return ResourceTypeEnum.DEVICEMETRIC;
10227        if ("DeviceRequest".equals(codeString))
10228          return ResourceTypeEnum.DEVICEREQUEST;
10229        if ("DeviceUseStatement".equals(codeString))
10230          return ResourceTypeEnum.DEVICEUSESTATEMENT;
10231        if ("DiagnosticReport".equals(codeString))
10232          return ResourceTypeEnum.DIAGNOSTICREPORT;
10233        if ("DocumentManifest".equals(codeString))
10234          return ResourceTypeEnum.DOCUMENTMANIFEST;
10235        if ("DocumentReference".equals(codeString))
10236          return ResourceTypeEnum.DOCUMENTREFERENCE;
10237        if ("DomainResource".equals(codeString))
10238          return ResourceTypeEnum.DOMAINRESOURCE;
10239        if ("Encounter".equals(codeString))
10240          return ResourceTypeEnum.ENCOUNTER;
10241        if ("Endpoint".equals(codeString))
10242          return ResourceTypeEnum.ENDPOINT;
10243        if ("EnrollmentRequest".equals(codeString))
10244          return ResourceTypeEnum.ENROLLMENTREQUEST;
10245        if ("EnrollmentResponse".equals(codeString))
10246          return ResourceTypeEnum.ENROLLMENTRESPONSE;
10247        if ("EpisodeOfCare".equals(codeString))
10248          return ResourceTypeEnum.EPISODEOFCARE;
10249        if ("EventDefinition".equals(codeString))
10250          return ResourceTypeEnum.EVENTDEFINITION;
10251        if ("Evidence".equals(codeString))
10252          return ResourceTypeEnum.EVIDENCE;
10253        if ("EvidenceVariable".equals(codeString))
10254          return ResourceTypeEnum.EVIDENCEVARIABLE;
10255        if ("ExampleScenario".equals(codeString))
10256          return ResourceTypeEnum.EXAMPLESCENARIO;
10257        if ("ExplanationOfBenefit".equals(codeString))
10258          return ResourceTypeEnum.EXPLANATIONOFBENEFIT;
10259        if ("FamilyMemberHistory".equals(codeString))
10260          return ResourceTypeEnum.FAMILYMEMBERHISTORY;
10261        if ("Flag".equals(codeString))
10262          return ResourceTypeEnum.FLAG;
10263        if ("Goal".equals(codeString))
10264          return ResourceTypeEnum.GOAL;
10265        if ("GraphDefinition".equals(codeString))
10266          return ResourceTypeEnum.GRAPHDEFINITION;
10267        if ("Group".equals(codeString))
10268          return ResourceTypeEnum.GROUP;
10269        if ("GuidanceResponse".equals(codeString))
10270          return ResourceTypeEnum.GUIDANCERESPONSE;
10271        if ("HealthcareService".equals(codeString))
10272          return ResourceTypeEnum.HEALTHCARESERVICE;
10273        if ("ImagingStudy".equals(codeString))
10274          return ResourceTypeEnum.IMAGINGSTUDY;
10275        if ("Immunization".equals(codeString))
10276          return ResourceTypeEnum.IMMUNIZATION;
10277        if ("ImmunizationEvaluation".equals(codeString))
10278          return ResourceTypeEnum.IMMUNIZATIONEVALUATION;
10279        if ("ImmunizationRecommendation".equals(codeString))
10280          return ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION;
10281        if ("ImplementationGuide".equals(codeString))
10282          return ResourceTypeEnum.IMPLEMENTATIONGUIDE;
10283        if ("Ingredient".equals(codeString))
10284          return ResourceTypeEnum.INGREDIENT;
10285        if ("InsurancePlan".equals(codeString))
10286          return ResourceTypeEnum.INSURANCEPLAN;
10287        if ("Invoice".equals(codeString))
10288          return ResourceTypeEnum.INVOICE;
10289        if ("Library".equals(codeString))
10290          return ResourceTypeEnum.LIBRARY;
10291        if ("Linkage".equals(codeString))
10292          return ResourceTypeEnum.LINKAGE;
10293        if ("List".equals(codeString))
10294          return ResourceTypeEnum.LIST;
10295        if ("Location".equals(codeString))
10296          return ResourceTypeEnum.LOCATION;
10297        if ("ManufacturedItemDefinition".equals(codeString))
10298          return ResourceTypeEnum.MANUFACTUREDITEMDEFINITION;
10299        if ("Measure".equals(codeString))
10300          return ResourceTypeEnum.MEASURE;
10301        if ("MeasureReport".equals(codeString))
10302          return ResourceTypeEnum.MEASUREREPORT;
10303        if ("Medication".equals(codeString))
10304          return ResourceTypeEnum.MEDICATION;
10305        if ("MedicationAdministration".equals(codeString))
10306          return ResourceTypeEnum.MEDICATIONADMINISTRATION;
10307        if ("MedicationDispense".equals(codeString))
10308          return ResourceTypeEnum.MEDICATIONDISPENSE;
10309        if ("MedicationKnowledge".equals(codeString))
10310          return ResourceTypeEnum.MEDICATIONKNOWLEDGE;
10311        if ("MedicationRequest".equals(codeString))
10312          return ResourceTypeEnum.MEDICATIONREQUEST;
10313        if ("MedicationUsage".equals(codeString))
10314          return ResourceTypeEnum.MEDICATIONUSAGE;
10315        if ("MedicinalProductDefinition".equals(codeString))
10316          return ResourceTypeEnum.MEDICINALPRODUCTDEFINITION;
10317        if ("MessageDefinition".equals(codeString))
10318          return ResourceTypeEnum.MESSAGEDEFINITION;
10319        if ("MessageHeader".equals(codeString))
10320          return ResourceTypeEnum.MESSAGEHEADER;
10321        if ("MolecularSequence".equals(codeString))
10322          return ResourceTypeEnum.MOLECULARSEQUENCE;
10323        if ("NamingSystem".equals(codeString))
10324          return ResourceTypeEnum.NAMINGSYSTEM;
10325        if ("NutritionIntake".equals(codeString))
10326          return ResourceTypeEnum.NUTRITIONINTAKE;
10327        if ("NutritionOrder".equals(codeString))
10328          return ResourceTypeEnum.NUTRITIONORDER;
10329        if ("Observation".equals(codeString))
10330          return ResourceTypeEnum.OBSERVATION;
10331        if ("ObservationDefinition".equals(codeString))
10332          return ResourceTypeEnum.OBSERVATIONDEFINITION;
10333        if ("OperationDefinition".equals(codeString))
10334          return ResourceTypeEnum.OPERATIONDEFINITION;
10335        if ("OperationOutcome".equals(codeString))
10336          return ResourceTypeEnum.OPERATIONOUTCOME;
10337        if ("Organization".equals(codeString))
10338          return ResourceTypeEnum.ORGANIZATION;
10339        if ("OrganizationAffiliation".equals(codeString))
10340          return ResourceTypeEnum.ORGANIZATIONAFFILIATION;
10341        if ("PackagedProductDefinition".equals(codeString))
10342          return ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION;
10343        if ("Parameters".equals(codeString))
10344          return ResourceTypeEnum.PARAMETERS;
10345        if ("Patient".equals(codeString))
10346          return ResourceTypeEnum.PATIENT;
10347        if ("PaymentNotice".equals(codeString))
10348          return ResourceTypeEnum.PAYMENTNOTICE;
10349        if ("PaymentReconciliation".equals(codeString))
10350          return ResourceTypeEnum.PAYMENTRECONCILIATION;
10351        if ("Person".equals(codeString))
10352          return ResourceTypeEnum.PERSON;
10353        if ("PlanDefinition".equals(codeString))
10354          return ResourceTypeEnum.PLANDEFINITION;
10355        if ("Practitioner".equals(codeString))
10356          return ResourceTypeEnum.PRACTITIONER;
10357        if ("PractitionerRole".equals(codeString))
10358          return ResourceTypeEnum.PRACTITIONERROLE;
10359        if ("Procedure".equals(codeString))
10360          return ResourceTypeEnum.PROCEDURE;
10361        if ("Provenance".equals(codeString))
10362          return ResourceTypeEnum.PROVENANCE;
10363        if ("Questionnaire".equals(codeString))
10364          return ResourceTypeEnum.QUESTIONNAIRE;
10365        if ("QuestionnaireResponse".equals(codeString))
10366          return ResourceTypeEnum.QUESTIONNAIRERESPONSE;
10367        if ("RegulatedAuthorization".equals(codeString))
10368          return ResourceTypeEnum.REGULATEDAUTHORIZATION;
10369        if ("RelatedPerson".equals(codeString))
10370          return ResourceTypeEnum.RELATEDPERSON;
10371        if ("RequestGroup".equals(codeString))
10372          return ResourceTypeEnum.REQUESTGROUP;
10373        if ("ResearchStudy".equals(codeString))
10374          return ResourceTypeEnum.RESEARCHSTUDY;
10375        if ("ResearchSubject".equals(codeString))
10376          return ResourceTypeEnum.RESEARCHSUBJECT;
10377        if ("Resource".equals(codeString))
10378          return ResourceTypeEnum.RESOURCE;
10379        if ("RiskAssessment".equals(codeString))
10380          return ResourceTypeEnum.RISKASSESSMENT;
10381        if ("Schedule".equals(codeString))
10382          return ResourceTypeEnum.SCHEDULE;
10383        if ("SearchParameter".equals(codeString))
10384          return ResourceTypeEnum.SEARCHPARAMETER;
10385        if ("ServiceRequest".equals(codeString))
10386          return ResourceTypeEnum.SERVICEREQUEST;
10387        if ("Slot".equals(codeString))
10388          return ResourceTypeEnum.SLOT;
10389        if ("Specimen".equals(codeString))
10390          return ResourceTypeEnum.SPECIMEN;
10391        if ("SpecimenDefinition".equals(codeString))
10392          return ResourceTypeEnum.SPECIMENDEFINITION;
10393        if ("StructureDefinition".equals(codeString))
10394          return ResourceTypeEnum.STRUCTUREDEFINITION;
10395        if ("StructureMap".equals(codeString))
10396          return ResourceTypeEnum.STRUCTUREMAP;
10397        if ("Subscription".equals(codeString))
10398          return ResourceTypeEnum.SUBSCRIPTION;
10399        if ("Substance".equals(codeString))
10400          return ResourceTypeEnum.SUBSTANCE;
10401        if ("SubstanceDefinition".equals(codeString))
10402          return ResourceTypeEnum.SUBSTANCEDEFINITION;
10403        if ("SubstanceNucleicAcid".equals(codeString))
10404          return ResourceTypeEnum.SUBSTANCENUCLEICACID;
10405        if ("SubstancePolymer".equals(codeString))
10406          return ResourceTypeEnum.SUBSTANCEPOLYMER;
10407        if ("SubstanceProtein".equals(codeString))
10408          return ResourceTypeEnum.SUBSTANCEPROTEIN;
10409        if ("SubstanceReferenceInformation".equals(codeString))
10410          return ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION;
10411        if ("SubstanceSourceMaterial".equals(codeString))
10412          return ResourceTypeEnum.SUBSTANCESOURCEMATERIAL;
10413        if ("SupplyDelivery".equals(codeString))
10414          return ResourceTypeEnum.SUPPLYDELIVERY;
10415        if ("SupplyRequest".equals(codeString))
10416          return ResourceTypeEnum.SUPPLYREQUEST;
10417        if ("Task".equals(codeString))
10418          return ResourceTypeEnum.TASK;
10419        if ("TerminologyCapabilities".equals(codeString))
10420          return ResourceTypeEnum.TERMINOLOGYCAPABILITIES;
10421        if ("TestReport".equals(codeString))
10422          return ResourceTypeEnum.TESTREPORT;
10423        if ("TestScript".equals(codeString))
10424          return ResourceTypeEnum.TESTSCRIPT;
10425        if ("Topic".equals(codeString))
10426          return ResourceTypeEnum.TOPIC;
10427        if ("ValueSet".equals(codeString))
10428          return ResourceTypeEnum.VALUESET;
10429        if ("VerificationResult".equals(codeString))
10430          return ResourceTypeEnum.VERIFICATIONRESULT;
10431        if ("VisionPrescription".equals(codeString))
10432          return ResourceTypeEnum.VISIONPRESCRIPTION;
10433        throw new IllegalArgumentException("Unknown ResourceTypeEnum code '"+codeString+"'");
10434        }
10435        public Enumeration<ResourceTypeEnum> fromType(Base code) throws FHIRException {
10436          if (code == null)
10437            return null;
10438          if (code.isEmpty())
10439            return new Enumeration<ResourceTypeEnum>(this);
10440          String codeString = ((PrimitiveType) code).asStringValue();
10441          if (codeString == null || "".equals(codeString))
10442            return null;
10443        if ("Account".equals(codeString))
10444          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACCOUNT);
10445        if ("ActivityDefinition".equals(codeString))
10446          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTIVITYDEFINITION);
10447        if ("AdministrableProductDefinition".equals(codeString))
10448          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION);
10449        if ("AdverseEvent".equals(codeString))
10450          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADVERSEEVENT);
10451        if ("AllergyIntolerance".equals(codeString))
10452          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ALLERGYINTOLERANCE);
10453        if ("Appointment".equals(codeString))
10454          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENT);
10455        if ("AppointmentResponse".equals(codeString))
10456          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENTRESPONSE);
10457        if ("AuditEvent".equals(codeString))
10458          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.AUDITEVENT);
10459        if ("Basic".equals(codeString))
10460          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BASIC);
10461        if ("Binary".equals(codeString))
10462          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BINARY);
10463        if ("BiologicallyDerivedProduct".equals(codeString))
10464          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT);
10465        if ("BodyStructure".equals(codeString))
10466          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BODYSTRUCTURE);
10467        if ("Bundle".equals(codeString))
10468          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BUNDLE);
10469        if ("CapabilityStatement".equals(codeString))
10470          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT);
10471        if ("CapabilityStatement2".equals(codeString))
10472          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT2);
10473        if ("CarePlan".equals(codeString))
10474          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAREPLAN);
10475        if ("CareTeam".equals(codeString))
10476          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CARETEAM);
10477        if ("CatalogEntry".equals(codeString))
10478          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CATALOGENTRY);
10479        if ("ChargeItem".equals(codeString))
10480          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEM);
10481        if ("ChargeItemDefinition".equals(codeString))
10482          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEMDEFINITION);
10483        if ("Claim".equals(codeString))
10484          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIM);
10485        if ("ClaimResponse".equals(codeString))
10486          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIMRESPONSE);
10487        if ("ClinicalImpression".equals(codeString))
10488          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALIMPRESSION);
10489        if ("ClinicalUseIssue".equals(codeString))
10490          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALUSEISSUE);
10491        if ("CodeSystem".equals(codeString))
10492          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CODESYSTEM);
10493        if ("Communication".equals(codeString))
10494          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATION);
10495        if ("CommunicationRequest".equals(codeString))
10496          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATIONREQUEST);
10497        if ("CompartmentDefinition".equals(codeString))
10498          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPARTMENTDEFINITION);
10499        if ("Composition".equals(codeString))
10500          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPOSITION);
10501        if ("ConceptMap".equals(codeString))
10502          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONCEPTMAP);
10503        if ("Condition".equals(codeString))
10504          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITION);
10505        if ("ConditionDefinition".equals(codeString))
10506          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITIONDEFINITION);
10507        if ("Consent".equals(codeString))
10508          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONSENT);
10509        if ("Contract".equals(codeString))
10510          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONTRACT);
10511        if ("Coverage".equals(codeString))
10512          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGE);
10513        if ("CoverageEligibilityRequest".equals(codeString))
10514          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST);
10515        if ("CoverageEligibilityResponse".equals(codeString))
10516          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE);
10517        if ("DetectedIssue".equals(codeString))
10518          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DETECTEDISSUE);
10519        if ("Device".equals(codeString))
10520          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICE);
10521        if ("DeviceDefinition".equals(codeString))
10522          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDEFINITION);
10523        if ("DeviceMetric".equals(codeString))
10524          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEMETRIC);
10525        if ("DeviceRequest".equals(codeString))
10526          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEREQUEST);
10527        if ("DeviceUseStatement".equals(codeString))
10528          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEUSESTATEMENT);
10529        if ("DiagnosticReport".equals(codeString))
10530          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DIAGNOSTICREPORT);
10531        if ("DocumentManifest".equals(codeString))
10532          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTMANIFEST);
10533        if ("DocumentReference".equals(codeString))
10534          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTREFERENCE);
10535        if ("DomainResource".equals(codeString))
10536          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOMAINRESOURCE);
10537        if ("Encounter".equals(codeString))
10538          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTER);
10539        if ("Endpoint".equals(codeString))
10540          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENDPOINT);
10541        if ("EnrollmentRequest".equals(codeString))
10542          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTREQUEST);
10543        if ("EnrollmentResponse".equals(codeString))
10544          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTRESPONSE);
10545        if ("EpisodeOfCare".equals(codeString))
10546          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EPISODEOFCARE);
10547        if ("EventDefinition".equals(codeString))
10548          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVENTDEFINITION);
10549        if ("Evidence".equals(codeString))
10550          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCE);
10551        if ("EvidenceVariable".equals(codeString))
10552          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEVARIABLE);
10553        if ("ExampleScenario".equals(codeString))
10554          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXAMPLESCENARIO);
10555        if ("ExplanationOfBenefit".equals(codeString))
10556          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXPLANATIONOFBENEFIT);
10557        if ("FamilyMemberHistory".equals(codeString))
10558          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FAMILYMEMBERHISTORY);
10559        if ("Flag".equals(codeString))
10560          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FLAG);
10561        if ("Goal".equals(codeString))
10562          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GOAL);
10563        if ("GraphDefinition".equals(codeString))
10564          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GRAPHDEFINITION);
10565        if ("Group".equals(codeString))
10566          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GROUP);
10567        if ("GuidanceResponse".equals(codeString))
10568          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GUIDANCERESPONSE);
10569        if ("HealthcareService".equals(codeString))
10570          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.HEALTHCARESERVICE);
10571        if ("ImagingStudy".equals(codeString))
10572          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSTUDY);
10573        if ("Immunization".equals(codeString))
10574          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATION);
10575        if ("ImmunizationEvaluation".equals(codeString))
10576          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONEVALUATION);
10577        if ("ImmunizationRecommendation".equals(codeString))
10578          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION);
10579        if ("ImplementationGuide".equals(codeString))
10580          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMPLEMENTATIONGUIDE);
10581        if ("Ingredient".equals(codeString))
10582          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INGREDIENT);
10583        if ("InsurancePlan".equals(codeString))
10584          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INSURANCEPLAN);
10585        if ("Invoice".equals(codeString))
10586          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVOICE);
10587        if ("Library".equals(codeString))
10588          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIBRARY);
10589        if ("Linkage".equals(codeString))
10590          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LINKAGE);
10591        if ("List".equals(codeString))
10592          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIST);
10593        if ("Location".equals(codeString))
10594          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LOCATION);
10595        if ("ManufacturedItemDefinition".equals(codeString))
10596          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MANUFACTUREDITEMDEFINITION);
10597        if ("Measure".equals(codeString))
10598          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASURE);
10599        if ("MeasureReport".equals(codeString))
10600          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASUREREPORT);
10601        if ("Medication".equals(codeString))
10602          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATION);
10603        if ("MedicationAdministration".equals(codeString))
10604          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONADMINISTRATION);
10605        if ("MedicationDispense".equals(codeString))
10606          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONDISPENSE);
10607        if ("MedicationKnowledge".equals(codeString))
10608          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONKNOWLEDGE);
10609        if ("MedicationRequest".equals(codeString))
10610          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONREQUEST);
10611        if ("MedicationUsage".equals(codeString))
10612          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONUSAGE);
10613        if ("MedicinalProductDefinition".equals(codeString))
10614          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICINALPRODUCTDEFINITION);
10615        if ("MessageDefinition".equals(codeString))
10616          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEDEFINITION);
10617        if ("MessageHeader".equals(codeString))
10618          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEHEADER);
10619        if ("MolecularSequence".equals(codeString))
10620          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MOLECULARSEQUENCE);
10621        if ("NamingSystem".equals(codeString))
10622          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NAMINGSYSTEM);
10623        if ("NutritionIntake".equals(codeString))
10624          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONINTAKE);
10625        if ("NutritionOrder".equals(codeString))
10626          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONORDER);
10627        if ("Observation".equals(codeString))
10628          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATION);
10629        if ("ObservationDefinition".equals(codeString))
10630          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATIONDEFINITION);
10631        if ("OperationDefinition".equals(codeString))
10632          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONDEFINITION);
10633        if ("OperationOutcome".equals(codeString))
10634          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONOUTCOME);
10635        if ("Organization".equals(codeString))
10636          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATION);
10637        if ("OrganizationAffiliation".equals(codeString))
10638          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATIONAFFILIATION);
10639        if ("PackagedProductDefinition".equals(codeString))
10640          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION);
10641        if ("Parameters".equals(codeString))
10642          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PARAMETERS);
10643        if ("Patient".equals(codeString))
10644          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PATIENT);
10645        if ("PaymentNotice".equals(codeString))
10646          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTNOTICE);
10647        if ("PaymentReconciliation".equals(codeString))
10648          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTRECONCILIATION);
10649        if ("Person".equals(codeString))
10650          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERSON);
10651        if ("PlanDefinition".equals(codeString))
10652          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PLANDEFINITION);
10653        if ("Practitioner".equals(codeString))
10654          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONER);
10655        if ("PractitionerRole".equals(codeString))
10656          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONERROLE);
10657        if ("Procedure".equals(codeString))
10658          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROCEDURE);
10659        if ("Provenance".equals(codeString))
10660          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROVENANCE);
10661        if ("Questionnaire".equals(codeString))
10662          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRE);
10663        if ("QuestionnaireResponse".equals(codeString))
10664          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRERESPONSE);
10665        if ("RegulatedAuthorization".equals(codeString))
10666          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REGULATEDAUTHORIZATION);
10667        if ("RelatedPerson".equals(codeString))
10668          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RELATEDPERSON);
10669        if ("RequestGroup".equals(codeString))
10670          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUESTGROUP);
10671        if ("ResearchStudy".equals(codeString))
10672          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSTUDY);
10673        if ("ResearchSubject".equals(codeString))
10674          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSUBJECT);
10675        if ("Resource".equals(codeString))
10676          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESOURCE);
10677        if ("RiskAssessment".equals(codeString))
10678          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RISKASSESSMENT);
10679        if ("Schedule".equals(codeString))
10680          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SCHEDULE);
10681        if ("SearchParameter".equals(codeString))
10682          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SEARCHPARAMETER);
10683        if ("ServiceRequest".equals(codeString))
10684          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SERVICEREQUEST);
10685        if ("Slot".equals(codeString))
10686          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SLOT);
10687        if ("Specimen".equals(codeString))
10688          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMEN);
10689        if ("SpecimenDefinition".equals(codeString))
10690          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMENDEFINITION);
10691        if ("StructureDefinition".equals(codeString))
10692          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREDEFINITION);
10693        if ("StructureMap".equals(codeString))
10694          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREMAP);
10695        if ("Subscription".equals(codeString))
10696          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTION);
10697        if ("Substance".equals(codeString))
10698          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCE);
10699        if ("SubstanceDefinition".equals(codeString))
10700          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEDEFINITION);
10701        if ("SubstanceNucleicAcid".equals(codeString))
10702          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCENUCLEICACID);
10703        if ("SubstancePolymer".equals(codeString))
10704          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPOLYMER);
10705        if ("SubstanceProtein".equals(codeString))
10706          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPROTEIN);
10707        if ("SubstanceReferenceInformation".equals(codeString))
10708          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION);
10709        if ("SubstanceSourceMaterial".equals(codeString))
10710          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCESOURCEMATERIAL);
10711        if ("SupplyDelivery".equals(codeString))
10712          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYDELIVERY);
10713        if ("SupplyRequest".equals(codeString))
10714          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYREQUEST);
10715        if ("Task".equals(codeString))
10716          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TASK);
10717        if ("TerminologyCapabilities".equals(codeString))
10718          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TERMINOLOGYCAPABILITIES);
10719        if ("TestReport".equals(codeString))
10720          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTREPORT);
10721        if ("TestScript".equals(codeString))
10722          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTSCRIPT);
10723        if ("Topic".equals(codeString))
10724          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TOPIC);
10725        if ("ValueSet".equals(codeString))
10726          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VALUESET);
10727        if ("VerificationResult".equals(codeString))
10728          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VERIFICATIONRESULT);
10729        if ("VisionPrescription".equals(codeString))
10730          return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VISIONPRESCRIPTION);
10731        throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'");
10732        }
10733    public String toCode(ResourceTypeEnum code) {
10734      if (code == ResourceTypeEnum.ACCOUNT)
10735        return "Account";
10736      if (code == ResourceTypeEnum.ACTIVITYDEFINITION)
10737        return "ActivityDefinition";
10738      if (code == ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION)
10739        return "AdministrableProductDefinition";
10740      if (code == ResourceTypeEnum.ADVERSEEVENT)
10741        return "AdverseEvent";
10742      if (code == ResourceTypeEnum.ALLERGYINTOLERANCE)
10743        return "AllergyIntolerance";
10744      if (code == ResourceTypeEnum.APPOINTMENT)
10745        return "Appointment";
10746      if (code == ResourceTypeEnum.APPOINTMENTRESPONSE)
10747        return "AppointmentResponse";
10748      if (code == ResourceTypeEnum.AUDITEVENT)
10749        return "AuditEvent";
10750      if (code == ResourceTypeEnum.BASIC)
10751        return "Basic";
10752      if (code == ResourceTypeEnum.BINARY)
10753        return "Binary";
10754      if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT)
10755        return "BiologicallyDerivedProduct";
10756      if (code == ResourceTypeEnum.BODYSTRUCTURE)
10757        return "BodyStructure";
10758      if (code == ResourceTypeEnum.BUNDLE)
10759        return "Bundle";
10760      if (code == ResourceTypeEnum.CAPABILITYSTATEMENT)
10761        return "CapabilityStatement";
10762      if (code == ResourceTypeEnum.CAPABILITYSTATEMENT2)
10763        return "CapabilityStatement2";
10764      if (code == ResourceTypeEnum.CAREPLAN)
10765        return "CarePlan";
10766      if (code == ResourceTypeEnum.CARETEAM)
10767        return "CareTeam";
10768      if (code == ResourceTypeEnum.CATALOGENTRY)
10769        return "CatalogEntry";
10770      if (code == ResourceTypeEnum.CHARGEITEM)
10771        return "ChargeItem";
10772      if (code == ResourceTypeEnum.CHARGEITEMDEFINITION)
10773        return "ChargeItemDefinition";
10774      if (code == ResourceTypeEnum.CLAIM)
10775        return "Claim";
10776      if (code == ResourceTypeEnum.CLAIMRESPONSE)
10777        return "ClaimResponse";
10778      if (code == ResourceTypeEnum.CLINICALIMPRESSION)
10779        return "ClinicalImpression";
10780      if (code == ResourceTypeEnum.CLINICALUSEISSUE)
10781        return "ClinicalUseIssue";
10782      if (code == ResourceTypeEnum.CODESYSTEM)
10783        return "CodeSystem";
10784      if (code == ResourceTypeEnum.COMMUNICATION)
10785        return "Communication";
10786      if (code == ResourceTypeEnum.COMMUNICATIONREQUEST)
10787        return "CommunicationRequest";
10788      if (code == ResourceTypeEnum.COMPARTMENTDEFINITION)
10789        return "CompartmentDefinition";
10790      if (code == ResourceTypeEnum.COMPOSITION)
10791        return "Composition";
10792      if (code == ResourceTypeEnum.CONCEPTMAP)
10793        return "ConceptMap";
10794      if (code == ResourceTypeEnum.CONDITION)
10795        return "Condition";
10796      if (code == ResourceTypeEnum.CONDITIONDEFINITION)
10797        return "ConditionDefinition";
10798      if (code == ResourceTypeEnum.CONSENT)
10799        return "Consent";
10800      if (code == ResourceTypeEnum.CONTRACT)
10801        return "Contract";
10802      if (code == ResourceTypeEnum.COVERAGE)
10803        return "Coverage";
10804      if (code == ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST)
10805        return "CoverageEligibilityRequest";
10806      if (code == ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE)
10807        return "CoverageEligibilityResponse";
10808      if (code == ResourceTypeEnum.DETECTEDISSUE)
10809        return "DetectedIssue";
10810      if (code == ResourceTypeEnum.DEVICE)
10811        return "Device";
10812      if (code == ResourceTypeEnum.DEVICEDEFINITION)
10813        return "DeviceDefinition";
10814      if (code == ResourceTypeEnum.DEVICEMETRIC)
10815        return "DeviceMetric";
10816      if (code == ResourceTypeEnum.DEVICEREQUEST)
10817        return "DeviceRequest";
10818      if (code == ResourceTypeEnum.DEVICEUSESTATEMENT)
10819        return "DeviceUseStatement";
10820      if (code == ResourceTypeEnum.DIAGNOSTICREPORT)
10821        return "DiagnosticReport";
10822      if (code == ResourceTypeEnum.DOCUMENTMANIFEST)
10823        return "DocumentManifest";
10824      if (code == ResourceTypeEnum.DOCUMENTREFERENCE)
10825        return "DocumentReference";
10826      if (code == ResourceTypeEnum.DOMAINRESOURCE)
10827        return "DomainResource";
10828      if (code == ResourceTypeEnum.ENCOUNTER)
10829        return "Encounter";
10830      if (code == ResourceTypeEnum.ENDPOINT)
10831        return "Endpoint";
10832      if (code == ResourceTypeEnum.ENROLLMENTREQUEST)
10833        return "EnrollmentRequest";
10834      if (code == ResourceTypeEnum.ENROLLMENTRESPONSE)
10835        return "EnrollmentResponse";
10836      if (code == ResourceTypeEnum.EPISODEOFCARE)
10837        return "EpisodeOfCare";
10838      if (code == ResourceTypeEnum.EVENTDEFINITION)
10839        return "EventDefinition";
10840      if (code == ResourceTypeEnum.EVIDENCE)
10841        return "Evidence";
10842      if (code == ResourceTypeEnum.EVIDENCEVARIABLE)
10843        return "EvidenceVariable";
10844      if (code == ResourceTypeEnum.EXAMPLESCENARIO)
10845        return "ExampleScenario";
10846      if (code == ResourceTypeEnum.EXPLANATIONOFBENEFIT)
10847        return "ExplanationOfBenefit";
10848      if (code == ResourceTypeEnum.FAMILYMEMBERHISTORY)
10849        return "FamilyMemberHistory";
10850      if (code == ResourceTypeEnum.FLAG)
10851        return "Flag";
10852      if (code == ResourceTypeEnum.GOAL)
10853        return "Goal";
10854      if (code == ResourceTypeEnum.GRAPHDEFINITION)
10855        return "GraphDefinition";
10856      if (code == ResourceTypeEnum.GROUP)
10857        return "Group";
10858      if (code == ResourceTypeEnum.GUIDANCERESPONSE)
10859        return "GuidanceResponse";
10860      if (code == ResourceTypeEnum.HEALTHCARESERVICE)
10861        return "HealthcareService";
10862      if (code == ResourceTypeEnum.IMAGINGSTUDY)
10863        return "ImagingStudy";
10864      if (code == ResourceTypeEnum.IMMUNIZATION)
10865        return "Immunization";
10866      if (code == ResourceTypeEnum.IMMUNIZATIONEVALUATION)
10867        return "ImmunizationEvaluation";
10868      if (code == ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION)
10869        return "ImmunizationRecommendation";
10870      if (code == ResourceTypeEnum.IMPLEMENTATIONGUIDE)
10871        return "ImplementationGuide";
10872      if (code == ResourceTypeEnum.INGREDIENT)
10873        return "Ingredient";
10874      if (code == ResourceTypeEnum.INSURANCEPLAN)
10875        return "InsurancePlan";
10876      if (code == ResourceTypeEnum.INVOICE)
10877        return "Invoice";
10878      if (code == ResourceTypeEnum.LIBRARY)
10879        return "Library";
10880      if (code == ResourceTypeEnum.LINKAGE)
10881        return "Linkage";
10882      if (code == ResourceTypeEnum.LIST)
10883        return "List";
10884      if (code == ResourceTypeEnum.LOCATION)
10885        return "Location";
10886      if (code == ResourceTypeEnum.MANUFACTUREDITEMDEFINITION)
10887        return "ManufacturedItemDefinition";
10888      if (code == ResourceTypeEnum.MEASURE)
10889        return "Measure";
10890      if (code == ResourceTypeEnum.MEASUREREPORT)
10891        return "MeasureReport";
10892      if (code == ResourceTypeEnum.MEDICATION)
10893        return "Medication";
10894      if (code == ResourceTypeEnum.MEDICATIONADMINISTRATION)
10895        return "MedicationAdministration";
10896      if (code == ResourceTypeEnum.MEDICATIONDISPENSE)
10897        return "MedicationDispense";
10898      if (code == ResourceTypeEnum.MEDICATIONKNOWLEDGE)
10899        return "MedicationKnowledge";
10900      if (code == ResourceTypeEnum.MEDICATIONREQUEST)
10901        return "MedicationRequest";
10902      if (code == ResourceTypeEnum.MEDICATIONUSAGE)
10903        return "MedicationUsage";
10904      if (code == ResourceTypeEnum.MEDICINALPRODUCTDEFINITION)
10905        return "MedicinalProductDefinition";
10906      if (code == ResourceTypeEnum.MESSAGEDEFINITION)
10907        return "MessageDefinition";
10908      if (code == ResourceTypeEnum.MESSAGEHEADER)
10909        return "MessageHeader";
10910      if (code == ResourceTypeEnum.MOLECULARSEQUENCE)
10911        return "MolecularSequence";
10912      if (code == ResourceTypeEnum.NAMINGSYSTEM)
10913        return "NamingSystem";
10914      if (code == ResourceTypeEnum.NUTRITIONINTAKE)
10915        return "NutritionIntake";
10916      if (code == ResourceTypeEnum.NUTRITIONORDER)
10917        return "NutritionOrder";
10918      if (code == ResourceTypeEnum.OBSERVATION)
10919        return "Observation";
10920      if (code == ResourceTypeEnum.OBSERVATIONDEFINITION)
10921        return "ObservationDefinition";
10922      if (code == ResourceTypeEnum.OPERATIONDEFINITION)
10923        return "OperationDefinition";
10924      if (code == ResourceTypeEnum.OPERATIONOUTCOME)
10925        return "OperationOutcome";
10926      if (code == ResourceTypeEnum.ORGANIZATION)
10927        return "Organization";
10928      if (code == ResourceTypeEnum.ORGANIZATIONAFFILIATION)
10929        return "OrganizationAffiliation";
10930      if (code == ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION)
10931        return "PackagedProductDefinition";
10932      if (code == ResourceTypeEnum.PARAMETERS)
10933        return "Parameters";
10934      if (code == ResourceTypeEnum.PATIENT)
10935        return "Patient";
10936      if (code == ResourceTypeEnum.PAYMENTNOTICE)
10937        return "PaymentNotice";
10938      if (code == ResourceTypeEnum.PAYMENTRECONCILIATION)
10939        return "PaymentReconciliation";
10940      if (code == ResourceTypeEnum.PERSON)
10941        return "Person";
10942      if (code == ResourceTypeEnum.PLANDEFINITION)
10943        return "PlanDefinition";
10944      if (code == ResourceTypeEnum.PRACTITIONER)
10945        return "Practitioner";
10946      if (code == ResourceTypeEnum.PRACTITIONERROLE)
10947        return "PractitionerRole";
10948      if (code == ResourceTypeEnum.PROCEDURE)
10949        return "Procedure";
10950      if (code == ResourceTypeEnum.PROVENANCE)
10951        return "Provenance";
10952      if (code == ResourceTypeEnum.QUESTIONNAIRE)
10953        return "Questionnaire";
10954      if (code == ResourceTypeEnum.QUESTIONNAIRERESPONSE)
10955        return "QuestionnaireResponse";
10956      if (code == ResourceTypeEnum.REGULATEDAUTHORIZATION)
10957        return "RegulatedAuthorization";
10958      if (code == ResourceTypeEnum.RELATEDPERSON)
10959        return "RelatedPerson";
10960      if (code == ResourceTypeEnum.REQUESTGROUP)
10961        return "RequestGroup";
10962      if (code == ResourceTypeEnum.RESEARCHSTUDY)
10963        return "ResearchStudy";
10964      if (code == ResourceTypeEnum.RESEARCHSUBJECT)
10965        return "ResearchSubject";
10966      if (code == ResourceTypeEnum.RESOURCE)
10967        return "Resource";
10968      if (code == ResourceTypeEnum.RISKASSESSMENT)
10969        return "RiskAssessment";
10970      if (code == ResourceTypeEnum.SCHEDULE)
10971        return "Schedule";
10972      if (code == ResourceTypeEnum.SEARCHPARAMETER)
10973        return "SearchParameter";
10974      if (code == ResourceTypeEnum.SERVICEREQUEST)
10975        return "ServiceRequest";
10976      if (code == ResourceTypeEnum.SLOT)
10977        return "Slot";
10978      if (code == ResourceTypeEnum.SPECIMEN)
10979        return "Specimen";
10980      if (code == ResourceTypeEnum.SPECIMENDEFINITION)
10981        return "SpecimenDefinition";
10982      if (code == ResourceTypeEnum.STRUCTUREDEFINITION)
10983        return "StructureDefinition";
10984      if (code == ResourceTypeEnum.STRUCTUREMAP)
10985        return "StructureMap";
10986      if (code == ResourceTypeEnum.SUBSCRIPTION)
10987        return "Subscription";
10988      if (code == ResourceTypeEnum.SUBSTANCE)
10989        return "Substance";
10990      if (code == ResourceTypeEnum.SUBSTANCEDEFINITION)
10991        return "SubstanceDefinition";
10992      if (code == ResourceTypeEnum.SUBSTANCENUCLEICACID)
10993        return "SubstanceNucleicAcid";
10994      if (code == ResourceTypeEnum.SUBSTANCEPOLYMER)
10995        return "SubstancePolymer";
10996      if (code == ResourceTypeEnum.SUBSTANCEPROTEIN)
10997        return "SubstanceProtein";
10998      if (code == ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION)
10999        return "SubstanceReferenceInformation";
11000      if (code == ResourceTypeEnum.SUBSTANCESOURCEMATERIAL)
11001        return "SubstanceSourceMaterial";
11002      if (code == ResourceTypeEnum.SUPPLYDELIVERY)
11003        return "SupplyDelivery";
11004      if (code == ResourceTypeEnum.SUPPLYREQUEST)
11005        return "SupplyRequest";
11006      if (code == ResourceTypeEnum.TASK)
11007        return "Task";
11008      if (code == ResourceTypeEnum.TERMINOLOGYCAPABILITIES)
11009        return "TerminologyCapabilities";
11010      if (code == ResourceTypeEnum.TESTREPORT)
11011        return "TestReport";
11012      if (code == ResourceTypeEnum.TESTSCRIPT)
11013        return "TestScript";
11014      if (code == ResourceTypeEnum.TOPIC)
11015        return "Topic";
11016      if (code == ResourceTypeEnum.VALUESET)
11017        return "ValueSet";
11018      if (code == ResourceTypeEnum.VERIFICATIONRESULT)
11019        return "VerificationResult";
11020      if (code == ResourceTypeEnum.VISIONPRESCRIPTION)
11021        return "VisionPrescription";
11022      return "?";
11023      }
11024    public String toSystem(ResourceTypeEnum code) {
11025      return code.getSystem();
11026      }
11027    }
11028
11029    public enum RestfulCapabilityMode {
11030        /**
11031         * The application acts as a client for this resource.
11032         */
11033        CLIENT, 
11034        /**
11035         * The application acts as a server for this resource.
11036         */
11037        SERVER, 
11038        /**
11039         * added to help the parsers
11040         */
11041        NULL;
11042        public static RestfulCapabilityMode fromCode(String codeString) throws FHIRException {
11043            if (codeString == null || "".equals(codeString))
11044                return null;
11045        if ("client".equals(codeString))
11046          return CLIENT;
11047        if ("server".equals(codeString))
11048          return SERVER;
11049        throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'");
11050        }
11051        public String toCode() {
11052          switch (this) {
11053            case CLIENT: return "client";
11054            case SERVER: return "server";
11055            default: return "?";
11056          }
11057        }
11058        public String getSystem() {
11059          switch (this) {
11060            case CLIENT: return "http://hl7.org/fhir/restful-capability-mode";
11061            case SERVER: return "http://hl7.org/fhir/restful-capability-mode";
11062            default: return "?";
11063          }
11064        }
11065        public String getDefinition() {
11066          switch (this) {
11067            case CLIENT: return "The application acts as a client for this resource.";
11068            case SERVER: return "The application acts as a server for this resource.";
11069            default: return "?";
11070          }
11071        }
11072        public String getDisplay() {
11073          switch (this) {
11074            case CLIENT: return "Client";
11075            case SERVER: return "Server";
11076            default: return "?";
11077          }
11078        }
11079    }
11080
11081  public static class RestfulCapabilityModeEnumFactory implements EnumFactory<RestfulCapabilityMode> {
11082    public RestfulCapabilityMode fromCode(String codeString) throws IllegalArgumentException {
11083      if (codeString == null || "".equals(codeString))
11084            if (codeString == null || "".equals(codeString))
11085                return null;
11086        if ("client".equals(codeString))
11087          return RestfulCapabilityMode.CLIENT;
11088        if ("server".equals(codeString))
11089          return RestfulCapabilityMode.SERVER;
11090        throw new IllegalArgumentException("Unknown RestfulCapabilityMode code '"+codeString+"'");
11091        }
11092        public Enumeration<RestfulCapabilityMode> fromType(Base code) throws FHIRException {
11093          if (code == null)
11094            return null;
11095          if (code.isEmpty())
11096            return new Enumeration<RestfulCapabilityMode>(this);
11097          String codeString = ((PrimitiveType) code).asStringValue();
11098          if (codeString == null || "".equals(codeString))
11099            return null;
11100        if ("client".equals(codeString))
11101          return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.CLIENT);
11102        if ("server".equals(codeString))
11103          return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.SERVER);
11104        throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'");
11105        }
11106    public String toCode(RestfulCapabilityMode code) {
11107      if (code == RestfulCapabilityMode.CLIENT)
11108        return "client";
11109      if (code == RestfulCapabilityMode.SERVER)
11110        return "server";
11111      return "?";
11112      }
11113    public String toSystem(RestfulCapabilityMode code) {
11114      return code.getSystem();
11115      }
11116    }
11117
11118    public enum SearchParamType {
11119        /**
11120         * Search parameter SHALL be a number (a whole number, or a decimal).
11121         */
11122        NUMBER, 
11123        /**
11124         * Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported.
11125         */
11126        DATE, 
11127        /**
11128         * Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces.
11129         */
11130        STRING, 
11131        /**
11132         * Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a "|", depending on the modifier used.
11133         */
11134        TOKEN, 
11135        /**
11136         * A reference to another resource (Reference or canonical).
11137         */
11138        REFERENCE, 
11139        /**
11140         * A composite search parameter that combines a search on two values together.
11141         */
11142        COMPOSITE, 
11143        /**
11144         * A search parameter that searches on a quantity.
11145         */
11146        QUANTITY, 
11147        /**
11148         * A search parameter that searches on a URI (RFC 3986).
11149         */
11150        URI, 
11151        /**
11152         * Special logic applies to this parameter per the description of the search parameter.
11153         */
11154        SPECIAL, 
11155        /**
11156         * added to help the parsers
11157         */
11158        NULL;
11159        public static SearchParamType fromCode(String codeString) throws FHIRException {
11160            if (codeString == null || "".equals(codeString))
11161                return null;
11162        if ("number".equals(codeString))
11163          return NUMBER;
11164        if ("date".equals(codeString))
11165          return DATE;
11166        if ("string".equals(codeString))
11167          return STRING;
11168        if ("token".equals(codeString))
11169          return TOKEN;
11170        if ("reference".equals(codeString))
11171          return REFERENCE;
11172        if ("composite".equals(codeString))
11173          return COMPOSITE;
11174        if ("quantity".equals(codeString))
11175          return QUANTITY;
11176        if ("uri".equals(codeString))
11177          return URI;
11178        if ("special".equals(codeString))
11179          return SPECIAL;
11180        throw new FHIRException("Unknown SearchParamType code '"+codeString+"'");
11181        }
11182        public String toCode() {
11183          switch (this) {
11184            case NUMBER: return "number";
11185            case DATE: return "date";
11186            case STRING: return "string";
11187            case TOKEN: return "token";
11188            case REFERENCE: return "reference";
11189            case COMPOSITE: return "composite";
11190            case QUANTITY: return "quantity";
11191            case URI: return "uri";
11192            case SPECIAL: return "special";
11193            default: return "?";
11194          }
11195        }
11196        public String getSystem() {
11197          switch (this) {
11198            case NUMBER: return "http://hl7.org/fhir/search-param-type";
11199            case DATE: return "http://hl7.org/fhir/search-param-type";
11200            case STRING: return "http://hl7.org/fhir/search-param-type";
11201            case TOKEN: return "http://hl7.org/fhir/search-param-type";
11202            case REFERENCE: return "http://hl7.org/fhir/search-param-type";
11203            case COMPOSITE: return "http://hl7.org/fhir/search-param-type";
11204            case QUANTITY: return "http://hl7.org/fhir/search-param-type";
11205            case URI: return "http://hl7.org/fhir/search-param-type";
11206            case SPECIAL: return "http://hl7.org/fhir/search-param-type";
11207            default: return "?";
11208          }
11209        }
11210        public String getDefinition() {
11211          switch (this) {
11212            case NUMBER: return "Search parameter SHALL be a number (a whole number, or a decimal).";
11213            case DATE: return "Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported.";
11214            case STRING: return "Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces.";
11215            case TOKEN: return "Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a \"|\", depending on the modifier used.";
11216            case REFERENCE: return "A reference to another resource (Reference or canonical).";
11217            case COMPOSITE: return "A composite search parameter that combines a search on two values together.";
11218            case QUANTITY: return "A search parameter that searches on a quantity.";
11219            case URI: return "A search parameter that searches on a URI (RFC 3986).";
11220            case SPECIAL: return "Special logic applies to this parameter per the description of the search parameter.";
11221            default: return "?";
11222          }
11223        }
11224        public String getDisplay() {
11225          switch (this) {
11226            case NUMBER: return "Number";
11227            case DATE: return "Date/DateTime";
11228            case STRING: return "String";
11229            case TOKEN: return "Token";
11230            case REFERENCE: return "Reference";
11231            case COMPOSITE: return "Composite";
11232            case QUANTITY: return "Quantity";
11233            case URI: return "URI";
11234            case SPECIAL: return "Special";
11235            default: return "?";
11236          }
11237        }
11238    }
11239
11240  public static class SearchParamTypeEnumFactory implements EnumFactory<SearchParamType> {
11241    public SearchParamType fromCode(String codeString) throws IllegalArgumentException {
11242      if (codeString == null || "".equals(codeString))
11243            if (codeString == null || "".equals(codeString))
11244                return null;
11245        if ("number".equals(codeString))
11246          return SearchParamType.NUMBER;
11247        if ("date".equals(codeString))
11248          return SearchParamType.DATE;
11249        if ("string".equals(codeString))
11250          return SearchParamType.STRING;
11251        if ("token".equals(codeString))
11252          return SearchParamType.TOKEN;
11253        if ("reference".equals(codeString))
11254          return SearchParamType.REFERENCE;
11255        if ("composite".equals(codeString))
11256          return SearchParamType.COMPOSITE;
11257        if ("quantity".equals(codeString))
11258          return SearchParamType.QUANTITY;
11259        if ("uri".equals(codeString))
11260          return SearchParamType.URI;
11261        if ("special".equals(codeString))
11262          return SearchParamType.SPECIAL;
11263        throw new IllegalArgumentException("Unknown SearchParamType code '"+codeString+"'");
11264        }
11265        public Enumeration<SearchParamType> fromType(Base code) throws FHIRException {
11266          if (code == null)
11267            return null;
11268          if (code.isEmpty())
11269            return new Enumeration<SearchParamType>(this);
11270          String codeString = ((PrimitiveType) code).asStringValue();
11271          if (codeString == null || "".equals(codeString))
11272            return null;
11273        if ("number".equals(codeString))
11274          return new Enumeration<SearchParamType>(this, SearchParamType.NUMBER);
11275        if ("date".equals(codeString))
11276          return new Enumeration<SearchParamType>(this, SearchParamType.DATE);
11277        if ("string".equals(codeString))
11278          return new Enumeration<SearchParamType>(this, SearchParamType.STRING);
11279        if ("token".equals(codeString))
11280          return new Enumeration<SearchParamType>(this, SearchParamType.TOKEN);
11281        if ("reference".equals(codeString))
11282          return new Enumeration<SearchParamType>(this, SearchParamType.REFERENCE);
11283        if ("composite".equals(codeString))
11284          return new Enumeration<SearchParamType>(this, SearchParamType.COMPOSITE);
11285        if ("quantity".equals(codeString))
11286          return new Enumeration<SearchParamType>(this, SearchParamType.QUANTITY);
11287        if ("uri".equals(codeString))
11288          return new Enumeration<SearchParamType>(this, SearchParamType.URI);
11289        if ("special".equals(codeString))
11290          return new Enumeration<SearchParamType>(this, SearchParamType.SPECIAL);
11291        throw new FHIRException("Unknown SearchParamType code '"+codeString+"'");
11292        }
11293    public String toCode(SearchParamType code) {
11294      if (code == SearchParamType.NUMBER)
11295        return "number";
11296      if (code == SearchParamType.DATE)
11297        return "date";
11298      if (code == SearchParamType.STRING)
11299        return "string";
11300      if (code == SearchParamType.TOKEN)
11301        return "token";
11302      if (code == SearchParamType.REFERENCE)
11303        return "reference";
11304      if (code == SearchParamType.COMPOSITE)
11305        return "composite";
11306      if (code == SearchParamType.QUANTITY)
11307        return "quantity";
11308      if (code == SearchParamType.URI)
11309        return "uri";
11310      if (code == SearchParamType.SPECIAL)
11311        return "special";
11312      return "?";
11313      }
11314    public String toSystem(SearchParamType code) {
11315      return code.getSystem();
11316      }
11317    }
11318
11319    public enum Use {
11320        /**
11321         * The treatment is complete and this represents a Claim for the services.
11322         */
11323        CLAIM, 
11324        /**
11325         * The treatment is proposed and this represents a Pre-authorization for the services.
11326         */
11327        PREAUTHORIZATION, 
11328        /**
11329         * The treatment is proposed and this represents a Pre-determination for the services.
11330         */
11331        PREDETERMINATION, 
11332        /**
11333         * added to help the parsers
11334         */
11335        NULL;
11336        public static Use fromCode(String codeString) throws FHIRException {
11337            if (codeString == null || "".equals(codeString))
11338                return null;
11339        if ("claim".equals(codeString))
11340          return CLAIM;
11341        if ("preauthorization".equals(codeString))
11342          return PREAUTHORIZATION;
11343        if ("predetermination".equals(codeString))
11344          return PREDETERMINATION;
11345        throw new FHIRException("Unknown Use code '"+codeString+"'");
11346        }
11347        public String toCode() {
11348          switch (this) {
11349            case CLAIM: return "claim";
11350            case PREAUTHORIZATION: return "preauthorization";
11351            case PREDETERMINATION: return "predetermination";
11352            default: return "?";
11353          }
11354        }
11355        public String getSystem() {
11356          switch (this) {
11357            case CLAIM: return "http://hl7.org/fhir/claim-use";
11358            case PREAUTHORIZATION: return "http://hl7.org/fhir/claim-use";
11359            case PREDETERMINATION: return "http://hl7.org/fhir/claim-use";
11360            default: return "?";
11361          }
11362        }
11363        public String getDefinition() {
11364          switch (this) {
11365            case CLAIM: return "The treatment is complete and this represents a Claim for the services.";
11366            case PREAUTHORIZATION: return "The treatment is proposed and this represents a Pre-authorization for the services.";
11367            case PREDETERMINATION: return "The treatment is proposed and this represents a Pre-determination for the services.";
11368            default: return "?";
11369          }
11370        }
11371        public String getDisplay() {
11372          switch (this) {
11373            case CLAIM: return "Claim";
11374            case PREAUTHORIZATION: return "Preauthorization";
11375            case PREDETERMINATION: return "Predetermination";
11376            default: return "?";
11377          }
11378        }
11379    }
11380
11381  public static class UseEnumFactory implements EnumFactory<Use> {
11382    public Use fromCode(String codeString) throws IllegalArgumentException {
11383      if (codeString == null || "".equals(codeString))
11384            if (codeString == null || "".equals(codeString))
11385                return null;
11386        if ("claim".equals(codeString))
11387          return Use.CLAIM;
11388        if ("preauthorization".equals(codeString))
11389          return Use.PREAUTHORIZATION;
11390        if ("predetermination".equals(codeString))
11391          return Use.PREDETERMINATION;
11392        throw new IllegalArgumentException("Unknown Use code '"+codeString+"'");
11393        }
11394        public Enumeration<Use> fromType(Base code) throws FHIRException {
11395          if (code == null)
11396            return null;
11397          if (code.isEmpty())
11398            return new Enumeration<Use>(this);
11399          String codeString = ((PrimitiveType) code).asStringValue();
11400          if (codeString == null || "".equals(codeString))
11401            return null;
11402        if ("claim".equals(codeString))
11403          return new Enumeration<Use>(this, Use.CLAIM);
11404        if ("preauthorization".equals(codeString))
11405          return new Enumeration<Use>(this, Use.PREAUTHORIZATION);
11406        if ("predetermination".equals(codeString))
11407          return new Enumeration<Use>(this, Use.PREDETERMINATION);
11408        throw new FHIRException("Unknown Use code '"+codeString+"'");
11409        }
11410    public String toCode(Use code) {
11411      if (code == Use.CLAIM)
11412        return "claim";
11413      if (code == Use.PREAUTHORIZATION)
11414        return "preauthorization";
11415      if (code == Use.PREDETERMINATION)
11416        return "predetermination";
11417      return "?";
11418      }
11419    public String toSystem(Use code) {
11420      return code.getSystem();
11421      }
11422    }
11423
11424
11425}
11426